BlockingQueue drainTo() method in Java with examples

Last Updated : 01 Nov, 2019

The drainTo(Collection col) method of BlockingQueue removes all available elements from this LinkedBlocking Queue and adds them to the given collection passed as a parameter.

Note: The drainTo() method of BlockingQueue has been inherited from the Queue class in Java.

drainTo(Collection<? super E> col)

The drainTo(Collection<? super E> col) method of BlockingQueue interface removes all of the elements from this queue and adds them to the given collection col. This is a more efficient way than repeatedly polling this queue.

There is also possibilities of failure encountered while attempting to add elements to collection c from the queue and due to that failure, elements is distributed between both collections when the associated exception is thrown. If a queue is tried to drainTo() to queue itself, then IllegalArgumentException will be thrown. If the specified collection is modified while the operation is in progress, the behavior of this operation is undefined. So for using such methods, one needs to take care of this type of situation to overcome exceptions.

Syntax:

public int drainTo(Collection<? super E> col)

Parameter: This method accepts one parameter col which represents the collection to transfer elements from LinkedBlockingQueue.

Return Value: This method returns the number of elements drained to collection from queue.

Exception: This method throws following exceptions:

UnsupportedOperationException– if collection cannot able to add elements.
ClassCastException– if class of element stops method to add element to collection.
NullPointerException– if the collection is null
IllegalArgumentException– if arguments of the method prevents it from being added to the specified collection

Below programs illustrates drainTo() method of BlockingQueue class:

Program 1:

// 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<Employee> BQ 
            = new LinkedBlockingQueue<Employee>(capacity); 
  
        // create a ArrayList to pass as parameter to drainTo() 
        ArrayList<Employee> collection = new ArrayList<Employee>(); 
  
        // 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); 
    } 
} 

Output:

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]]

Program 2:

// 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<Integer> 
            BQ = new LinkedBlockingQueue<Integer>(capacityOfQueue); 
  
        // add elements to queue 
        BQ.put(85461); 
        BQ.put(44648); 
        BQ.put(45654); 
  
        // create a collection with null 
        ArrayList<Integer> add = null; 
  
        // try to drain null queue to collection 
        try { 
            BQ.drainTo(add); 
        } 
        catch (Exception e) { 
            System.out.println("Exception: " + e); 
        } 
    } 
} 

Output:

Exception: java.lang.NullPointerException

drainTo(Collection<? super E> col, int maxElements)

The drainTo(Collection<? super E> col, int maxElements) used to transfer fixed number elements which is passed as integer in drainTo() to collection which is also passed as parameter to method. After transferring the elements, BlockingQueue has only those elements which are not transferred to collection. This function is same as above function with some limitations to transfer fixed no of element.

Syntax:

public int drainTo(Collection<? super E> col, int maxElements)

Parameter: The method accepts two parameters:

col– It represents the collection to transfer elements from BlockingQueue.
maxElements– This is of integer type and refers to the maximum number of elements to be transferred to the collection.

Return Value: The method returns the number of elements drained to collection from queue.

Exception: This method throws following exceptions:

UnsupportedOperationException – if collection cannot able to add elements.
ClassCastException -if class of element stops method to add element to collection.
NullPointerException – if the collection is null
IllegalArgumentException – if arguments of the method prevents it from being added to the specified collection

Below programs illustrates drainTo(Collection<? super E> col, int maxElements) method of BlockingQueue class

Program 1:

Below program has a BlockingQueue which stores Employee objects and there is a HashSet in which will store all employee objects from BlockingQueue. So drainTo() of BlockingQueue is used to pass some employee from queue to ArrayList. So no of element to be transferred is passed in method as parameter.

// 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<Employee> BQ 
            = new LinkedBlockingQueue<Employee>(capacity); 
  
        // create a HashSet to pass as parameter to drainTo() 
        HashSet<Employee> collection = new HashSet<Employee>(); 
  
        // 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<Employee> 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); 
    } 
} 

Output:

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]

Reference:

BlockingQueue take() method in Java with examples

gopaldave

Improve

Article Tags :

Practice Tags :

BlockingQueue drainTo() method in Java with examples

drainTo(Collection<? super E> col)

drainTo(Collection<? super E> col, int maxElements)

Similar Reads

Thank You!

What kind of Experience do you want to share?