Java中的LinkedBlockingDeque drainTo() 方法示例
LinkedBlockingDeque 的drainTo(Collection col)方法从此 LinkedBlockingDeque 中移除所有可用元素，并将它们添加到作为参数传递的给定集合中。
drainTo(Collection col)
LinkedBlockingDeque 的drainTo(Collection
在尝试将元素从双端队列添加到集合 c 时，也有可能遇到失败，并且由于该失败，当引发关联的异常时，元素会分布在两个集合之间。如果一个双端队列试图通过 drainTo() 来对自身进行双端队列，那么 IllegalArgumentException 将被抛出。如果在操作进行时修改了指定的集合，则此操作的行为是未定义的。因此，对于使用此类方法，需要注意这种情况以克服异常。
句法：
public int drainTo(Collection col)参数：此方法接受一个参数col ，该参数表示要从 LinkedBlockingDeque 传输元素的集合。
返回值：此方法返回从双端队列排出到集合的元素数。
异常：此方法抛出以下异常：
- UnsupportedOperationException – 如果集合无法添加元素。
- ClassCastException – 如果元素的类停止将元素添加到集合的方法。
- NullPointerException – 如果集合为空
- IllegalArgumentException – 如果方法的参数阻止它被添加到指定的集合中
下面的程序说明了 LinkedBlockingDeque 类的 drainTo() 方法：
方案一：
下面的程序有一个存储 Employee 对象的 LinkedBlockingDeque。有一个 ArrayList 将存储来自 LinkedBlockingDeque 的所有员工对象。所以 drainTo() 与 LinkedBlockingDeque 一起使用，将所有员工从 deque 传递到 ArrayList。
// Java Program Demonstrate drainTo(Collection c)
// method of LinkedBlockingDeque.
import java.util.ArrayList;
import java.util.concurrent.LinkedBlockingDeque;
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 LinkedBlockingDeque
int capacity = 50;
// create object of LinkedBlockingDeque
LinkedBlockingDeque linkedDeque
= new LinkedBlockingDeque(capacity);
// create a ArrayList to pass as parameter to drainTo()
ArrayList collection
= new ArrayList();
// add Employee object to deque
Employee emp1 = new Employee("Aman", "Analyst", "24000");
Employee emp2 = new Employee("Sachin", "Developer", "39000");
linkedDeque.add(emp1);
linkedDeque.add(emp2);
// printing Arraylist and deque
System.out.println("Before drainTo():");
System.out.println("LinkedBlockingDeque : \n"
+ linkedDeque.toString());
System.out.println("ArrayList : \n"
+ collection);
// Apply drainTo method and pass collection as parameter
int response = linkedDeque.drainTo(collection);
// print no of element passed
System.out.println("\nNo of element passed: "
+ response);
// printing Arraylist and deque
// after applying drainTo() method
System.out.println("\nAfter drainTo():");
System.out.println("LinkedBlockingDeque : \n"
+ linkedDeque.toString());
System.out.println("ArrayList : \n"
+ collection);
}
}
输出：
Before drainTo():
LinkedBlockingDeque :
[Employee [name=Aman, position=Analyst, salary=24000], Employee [name=Sachin, position=Developer, salary=39000]]
ArrayList :
[]
No of element passed: 2
After drainTo():
LinkedBlockingDeque :
[]
ArrayList :
[Employee [name=Aman, position=Analyst, salary=24000], Employee [name=Sachin, position=Developer, salary=39000]]
程序 2：显示由 drainTo() 方法抛出的异常的程序。
// Java Program Demonstrate
// drainTo(Collection C)
// method of LinkedBlockingDeque.
import java.util.ArrayList;
import java.util.concurrent.LinkedBlockingDeque;
public class GFG {
public static void main(String[] args)
throws InterruptedException
{
// define capacity of LinkedBlockingDeque
int capacityOfDeque = 4;
// create object of LinkedBlockingDeque
LinkedBlockingDeque linkedDeque
= new LinkedBlockingDeque(capacityOfDeque);
// add elements to deque
linkedDeque.put(85461);
linkedDeque.put(44648);
linkedDeque.put(45654);
// create a collection with null
ArrayList add = null;
// try to drain null deque to collection
try {
linkedDeque.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() 中作为整数传递的集合，该集合也作为参数传递给方法。转移元素后，LinkedBlockingDeque 只拥有那些未转移到集合中的元素。此函数与上述函数相同，但对于传输固定数量的元素有一些限制。
句法：
public int drainTo(Collection col, int maxElements) 参数：该方法接受两个参数：
- col – 它表示从 LinkedBlockingDeque 传输元素的集合。
- maxElements – 这是整数类型，是指要传输到集合的最大元素数。
返回值：该方法返回从双端队列排出到集合的元素数。
异常：此方法抛出以下异常：
- UnsupportedOperationException – 如果集合无法添加元素。
- ClassCastException - 如果元素类停止将元素添加到集合的方法。
- NullPointerException – 如果集合为空
- IllegalArgumentException – 如果方法的参数阻止它被添加到指定的集合中
下面的程序说明了 LinkedBlockingDeque 类的 drainTo(Collection col, int maxElements) 方法
方案一：
下面的程序有一个 LinkedBlockingDeque 存储 Employee 对象，还有一个 HashSet 将存储来自 LinkedBlockingDeque 的所有员工对象。所以 LinkedBlockingDeque 的 drainTo() 用于将一些员工从 deque 传递到 ArrayList。因此，没有要传输的元素作为参数传入方法中。
// Java program to demonstrate drainTo()
// method of LinkedBlockingDeque.
import java.util.*;
import java.util.concurrent.LinkedBlockingDeque;
public class GFG {
// create an 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 LinkedBlockingDeque
int capacity = 10;
// create object of LinkedBlockingDeque
LinkedBlockingDeque linkedDeque
= new LinkedBlockingDeque(capacity);
// create a HashSet to pass as parameter to drainTo()
HashSet collection
= new HashSet();
// add Employee object to deque
Employee emp1 = new Employee("Sachin",
"Analyst",
"40000");
Employee emp2 = new Employee("Aman",
"Developer",
"69000");
Employee emp3 = new Employee("Kajal",
"Accountant",
"39000");
linkedDeque.add(emp1);
linkedDeque.add(emp2);
linkedDeque.add(emp3);
// printing Arraylist and deque
// before applying drainTo() method
System.out.println("Before drainTo():");
System.out.println("No of Elements in Deque is "
+ linkedDeque.size());
System.out.println("Elements in Deque is as follows");
Iterator listOfemp
= linkedDeque.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
= linkedDeque.drainTo(collection, noOfElement);
// print no of element passed
System.out.println("\nNo of element passed: "
+ response);
// printing Arraylist and deque
// after applying drainTo() method
System.out.println("\nAfter drainTo():");
System.out.println("No of Elements in Deque is "
+ linkedDeque.size());
System.out.println("Elements in Deque is as follows");
listOfemp = linkedDeque.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 Deque is 3
Elements in Deque 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 Deque is 1
Elements in Deque 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]