📌  相关文章
📜  Java中的 BlockingQueue drainTo() 方法及示例

📅  最后修改于: 2022-05-13 01:55:42.936000             🧑  作者: Mango

Java中的 BlockingQueue drainTo() 方法及示例

BlockingQueue 的drainTo(Collection col)方法从此 LinkedBlocking Queue 中删除所有可用元素，并将它们添加到作为参数传递的给定集合中。

注意： BlockingQueue的drainTo()方法继承自Java中的Queue类。

drainTo(Collection col)

BlockingQueue接口的drainTo(Collection col)方法从该队列中移除所有元素并将它们添加到给定的集合 col。这是比重复轮询此队列更有效的方法。

在尝试将元素从队列中添加到集合 c 时，也有可能遇到失败，并且由于该失败，当引发关联的异常时，元素会在两个集合之间分布。如果一个队列试图通过 drainTo() 来排队，那么 IllegalArgumentException 将被抛出。如果在操作进行时修改了指定的集合，则此操作的行为是未定义的。因此，对于使用此类方法，需要注意这种情况以克服异常。

句法： 

public int drainTo(Collection col)

参数：此方法接受一个参数col ，该参数表示要从 LinkedBlockingQueue 传输元素的集合。

返回值：此方法返回从队列中排出到集合的元素数。

异常：此方法抛出以下异常：

  • UnsupportedOperationException – 如果集合无法添加元素。
  • ClassCastException – 如果元素的类停止将元素添加到集合的方法。
  • NullPointerException – 如果集合为空
  • IllegalArgumentException – 如果方法的参数阻止它被添加到指定的集合中

下面的程序说明了 BlockingQueue 类的 drainTo() 方法：

方案一： 

// Java Program Demonstrate drainTo(Collection c)
// method of BlockingQueue.
  
import java.util.ArrayList;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
  
public class GFG {
  
    // create a 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 BlockingQueue
        int capacity = 50;
  
        // create object of BlockingQueue
        BlockingQueue BQ
            = new LinkedBlockingQueue(capacity);
  
        // create a ArrayList to pass as parameter to drainTo()
        ArrayList collection = new ArrayList();
  
        // add Employee object to queue
        Employee emp1 = new Employee("Aman", "Analyst", "24000");
        Employee emp2 = new Employee("Sachin", "Developer", "39000");
        BQ.add(emp1);
        BQ.add(emp2);
  
        // printing Arraylist and queue
        System.out.println("Before drainTo():");
        System.out.println("BlockingQueue : \n"
                           + BQ.toString());
        System.out.println("ArrayList : \n"
                           + collection);
  
        // Apply drainTo method and pass collection as parameter
        int response = BQ.drainTo(collection);
  
        // print no of element passed
        System.out.println("\nNo of element passed: " + response);
  
        // printing Arraylist and queue after applying drainTo() method
        System.out.println("\nAfter drainTo():");
        System.out.println("BlockingQueue : \n"
                           + BQ.toString());
        System.out.println("ArrayList : \n"
                           + collection);
    }
}
输出： 
Before drainTo():
LinkedBlockingQueue : 
[Employee [name=Aman, position=Analyst, salary=24000], Employee [name=Sachin, position=Developer, salary=39000]]
ArrayList : 
[]

No of element passed: 2

After drainTo():
LinkedBlockingQueue : 
[]
ArrayList : 
[Employee [name=Aman, position=Analyst, salary=24000], Employee [name=Sachin, position=Developer, salary=39000]]

方案二： 

// Java Program Demonstrate
// drainTo(Collection C)
// method of BlockingQueue.
  
import java.util.ArrayList;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
  
public class GFG {
  
    public static void main(String[] args)
        throws InterruptedException
    {
        // define capacity of BlockingQueue
        int capacityOfQueue = 4;
  
        // create object of BlockingQueue
        BlockingQueue
            BQ = new LinkedBlockingQueue(capacityOfQueue);
  
        // add elements to queue
        BQ.put(85461);
        BQ.put(44648);
        BQ.put(45654);
  
        // create a collection with null
        ArrayList add = null;
  
        // try to drain null queue to collection
        try {
            BQ.drainTo(add);
        }
        catch (Exception e) {
            System.out.println("Exception: " + e);
        }
    }
}
输出： 
Exception: java.lang.NullPointerException

drainTo(Collection col, int maxElements)

drainTo(Collection col, int maxElements)用于将固定数量的元素传递给在 drainTo() 中作为整数传递的集合，该集合也作为参数传递给方法。转移元素后，BlockingQueue 中只有那些没有转移到集合中的元素。此函数与上述函数相同，但对于传输固定数量的元素有一些限制。

句法： 

public int drainTo(Collection col, int maxElements)

参数：该方法接受两个参数：

  • col - 它表示从 BlockingQueue 传输元素的集合。
  • maxElements – 这是整数类型，是指要传输到集合的最大元素数。

返回值：该方法返回从队列中排出到集合的元素数。

异常：此方法抛出以下异常：

  • UnsupportedOperationException – 如果集合无法添加元素。
  • ClassCastException - 如果元素类停止将元素添加到集合的方法。
  • NullPointerException – 如果集合为空
  • IllegalArgumentException – 如果方法的参数阻止它被添加到指定的集合中

下面的程序说明了 BlockingQueue 类的 drainTo(Collection col, int maxElements) 方法

方案一：

下面的程序有一个 BlockingQueue 存储 Employee 对象，还有一个 HashSet 将存储来自 BlockingQueue 的所有员工对象。因此 BlockingQueue 的 drainTo() 用于将一些员工从队列传递到 ArrayList。因此，没有要传输的元素作为参数传入方法中。 

// Java program  to demonstrate drainTo()
// method of BlockingQueue.
  
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
  
public class GFG {
  
    // create a Employee Object with
    // position and salary as 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 BlockingQueue
        int capacity = 10;
  
        // create object of BlockingQueue
        BlockingQueue BQ
            = new LinkedBlockingQueue(capacity);
  
        // create a HashSet to pass as parameter to drainTo()
        HashSet collection = new HashSet();
  
        // add Employee object to queue
        Employee emp1 = new Employee("Sachin", "Analyst", "40000");
        Employee emp2 = new Employee("Aman", "Developer", "69000");
        Employee emp3 = new Employee("Kajal", "Accountant", "39000");
        BQ.add(emp1);
        BQ.add(emp2);
        BQ.add(emp3);
  
        // printing Arraylist and queue before applying drainTo() method
        System.out.println("Before drainTo():");
        System.out.println("No of Elements in Queue is " + BQ.size());
        System.out.println("Elements in Queue is as follows");
        Iterator listOfemp = BQ.iterator();
        while (listOfemp.hasNext())
            System.out.println(listOfemp.next());
  
        System.out.println("No of Elements in HashSet is " + collection.size());
        System.out.println("Elements in HashSet is as follows:");
        for (Employee emp : collection)
            System.out.println(emp);
  
        // Initialize no of element passed to collection
        // using drainTo() method
        int noOfElement = 2;
  
        // Apply drainTo method and pass collection as parameter
        int response = BQ.drainTo(collection, noOfElement);
  
        // print no of element passed
        System.out.println("\nNo of element passed: " + response);
  
        // printing Arraylist and queue after applying drainTo() method
        System.out.println("\nAfter drainTo():");
        System.out.println("No of Elements in Queue is " + BQ.size());
        System.out.println("Elements in Queue is as follows");
        listOfemp = BQ.iterator();
        while (listOfemp.hasNext())
            System.out.println(listOfemp.next());
  
        System.out.println("No of Elements in HashSet is " + collection.size());
        System.out.println("Elements in HashSet is as follows:");
        for (Employee emp : collection)
            System.out.println(emp);
    }
}
输出： 
Before drainTo():
No of Elements in Queue is 3
Elements in Queue is as follows
Employee [name=Sachin, position=Analyst, salary=40000]
Employee [name=Aman, position=Developer, salary=69000]
Employee [name=Kajal, position=Accountant, salary=39000]
No of Elements in HashSet is 0
Elements in HashSet is as follows:

No of element passed: 2

After drainTo():
No of Elements in Queue is 1
Elements in Queue is as follows
Employee [name=Kajal, position=Accountant, salary=39000]
No of Elements in HashSet is 2
Elements in HashSet is as follows:
Employee [name=Sachin, position=Analyst, salary=40000]
Employee [name=Aman, position=Developer, salary=69000]

参考：

  • https://docs.oracle.com/javase/7/docs/api/java Java Java)
  • https://docs.oracle.com/javase/7/docs/api/java Java Java, %20int)