Java中的LinkedBlockingQueue contains（）方法-yiteyi-C++库

这个 包含（对象obj） 如果队列包含作为参数传递的对象obj，则LinkedBlockingQueue的方法返回true。当且仅当此队列包含至少一个元素e，该元素e等于作为参数传递的对象o，即e等于（o），则返回true。这个方法对于检查队列是否有元素非常有用。

null

语法：

public boolean contains(Object o)

参数： 此方法采用强制参数 o 这是队列中要检查的对象。

返回值： 此方法返回 符合事实的 如果此队列包含作为参数传递的对象。否则它就会回来 错误的 .

下面的程序演示了LinkedBlockingQueue类的contains（）方法：

项目1： 检查数字队列是否包含数字n。数字n作为输入传递给LinkedBlockingQueue的contains（）。

                     // Java Program Demonstrate contains(Object o)                   
                     // method of LinkedBlockingQueue                   
                             
                     import                               java.util.concurrent.LinkedBlockingQueue;                   
                             
                     public                               class                               GFG {                   
                             
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // define capacity of LinkedBlockingQueue                   
                                         int                               capacityOfQueue =                               50                               ;                   
                             
                                         // create object of LinkedBlockingQueue                   
                                         LinkedBlockingQueue<Integer> linkedQueue                   
                                         =                               new                               LinkedBlockingQueue<Integer>(capacityOfQueue);                   
                             
                                         // Add element to LinkedBlockingQueue                   
                                         linkedQueue.add(                               2300                               );                   
                                         linkedQueue.add(                               1322                               );                   
                                         linkedQueue.add(                               8945                               );                   
                                         linkedQueue.add(                               6512                               );                   
                             
                                         // print LinkedQueue                   
                                         System.out.println(                               "linkedQueue: "                               + linkedQueue);                   
                             
                                         // check whether LinkedBlockingQueue contains 6512                   
                                         boolean                               response1 = linkedQueue.contains(                               6512                               );                   
                             
                                         // print result                   
                                         System.out.println(                               "LinkedBlockingQueue contains "                   
                                         +                               "number 6512 : "                   
                                         + response1);                   
                             
                                         // check whether LinkedBlockingQueue contains 5324                   
                                         boolean                               response2 = linkedQueue.contains(                               5324                               );                   
                             
                                         // print result                   
                                         System.out.println(                               "LinkedBlockingQueue contains"                   
                                         +                               " number 5324 : "                   
                                         + response2);                   
                                         }                   
                     }                   

输出：

linkedQueue: [2300, 1322, 8945, 6512]

LinkedBlockingQueue contains number 6512 : true
LinkedBlockingQueue contains number 5324 : false

项目2： 检查员工队列是否包含特定的员工e。员工e的详细信息作为输入传递给LinkedBlockingQueue的contains（）。

                     // Java Program Demonstrate contains(Object o)                   
                     // method of LinkedBlockingQueue.                   
                             
                     import                               java.util.concurrent.LinkedBlockingQueue;                   
                             
                     public                               class                               GFG {                   
                             
                                         // create an Employee Object with                   
                                         // position and salary as an attribute                   
                                         public                               class                               Employee {                   
                             
                                         public                               String name;                   
                                         public                               String position;                   
                                         public                               String salary;                   
                             
                                         Employee(String name, String position, String salary)                   
                                         {                   
                                         this                               .name = name;                   
                                         this                               .position = position;                   
                                         this                               .salary = salary;                   
                                         }                   
                             
                                         @Override                   
                                         public                               String toString()                   
                                         {                   
                                         return                               "Employee [name="                               + name +                               ", position="                   
                                         + position +                               ", salary="                               + salary +                               "]"                               ;                   
                                         }                   
                                         }                   
                             
                                         // Main Method                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         GFG gfg =                               new                               GFG();                   
                                         gfg.containsMethodExample();                   
                                         }                   
                             
                                         public                               void                               containsMethodExample()                   
                                         {                   
                             
                                         // define capacity of LinkedBlockingQueue                   
                                         int                               capacity =                               50                               ;                   
                             
                                         // create object of LinkedBlockingQueue                   
                                         LinkedBlockingQueue<Employee> linkedQueue                   
                                         =                               new                               LinkedBlockingQueue<Employee>(capacity);                   
                             
                                         Employee emp1 =                               new                               Employee(                               "Aman"                               ,                   
                                         "Analyst"                               ,                   
                                         "24000"                               );                   
                                         Employee emp2 =                               new                               Employee(                               "Sachin"                               ,                   
                                         "Developer"                               ,                   
                                         "39000"                               );                   
                             
                                         // Add Employee Objects to linkedQueue                   
                                         linkedQueue.add(emp1);                   
                                         linkedQueue.add(emp2);                   
                             
                                         // print LinkedQueue                   
                                         System.out.println(                               "linkedQueue: "                               + linkedQueue);                   
                             
                                         // Employee to be checked                   
                                         Employee checkEmp1 =                               new                               Employee(                               "Sanjeev"                               ,                   
                                         "Tester"                               ,                   
                                         "26000"                               );                   
                             
                                         // check whether linkedQueue contains emp1                   
                                         boolean                               response1 = linkedQueue.contains(emp1);                   
                             
                                         // print results                   
                                         System.out.println(                               "linkedQueue contains "                   
                                         + emp1.toString() +                               " : "                   
                                         + response1);                   
                             
                                         // check whether linkedQueue contains checkEmp1                   
                                         boolean                               response2 = linkedQueue.contains(checkEmp1);                   
                             
                                         // print results                   
                                         System.out.println(                               "linkedQueue contains "                   
                                         + checkEmp1.toString() +                               " : "                   
                                         + response2);                   
                                         }                   
                     }                   

输出：

linkedQueue: 
[Employee [name=Aman, position=Analyst, salary=24000], 
Employee [name=Sachin, position=Developer, salary=39000]]

linkedQueue contains Employee [name=Aman, position=Analyst, salary=24000] : true
linkedQueue contains Employee [name=Sanjeev, position=Tester, salary=26000] : false

参考： https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/LinkedBlockingQueue.html#contains-爪哇。lang.反对-

文章版权归作者所有，未经允许请勿转载。

THE END

Java