极客教程LinkedBlockingDeque drainTo() 方法在Java中的示例
LinkedBlockingDeque 的 drainTo(Collection col) 方法会从此 LinkedBlockingDeque 中删除所有可用的元素，并将它们添加到传递作为参数的给定集合中。
drainTo(Collection col)
LinkedBlockingDeque 的 **drainTo(Collection
在尝试从 deque 中添加元素到集合 c 时也可能会遇到失败的情况，由于这个故障，与关联异常一起抛出时，元素会分配到两个集合中。如果将 deque 尝试转移到 deque 本身，则会抛出 IllegalArgumentException。如果在操作进行时修改指定的集合，则此操作的行为是未定义的。所以，使用这种方法需要注意这种类型的情况以克服异常。
语法：
public int drainTo(Collection<? super E> col)
参数： 此方法接受一个参数 col，它代表从 LinkedBlockingDeque 转移元素的集合。
返回值： 此方法返回从 deque 中传输到集合中的元素数量。
异常： 此方法会抛出以下异常：
- UnsupportedOperationException – 如果集合无法添加元素。
- ClassCastException – 如果元素的类阻止方法向集合中添加元素。
- NullPointerException – 如果集合为空。
- IllegalArgumentException – 如果方法的参数防止它被添加到指定的集合中。
下面的程序说明了 LinkedBlockingDeque 类的 drainTo() 方法：
程序1：
以下程序有一个存储 Employee 对象的 LinkedBlockingDeque。有一个 ArrayList，它将从 LinkedBlockingDeque 中存储所有的 Employee 对象。因此，使用 LinkedBlockingDeque 的 drainTo() 将所有 Employee 从 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<Employee> linkedDeque
= new LinkedBlockingDeque<Employee>(capacity);
// create a ArrayList to pass as parameter to drainTo()
ArrayList<Employee> collection
= new ArrayList<Employee>();
// 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程序演示
// drainTo(Collection C)
// LinkedBlockingDeque的方法。
import java.util.ArrayList;
import java.util.concurrent.LinkedBlockingDeque;
public class GFG {
public static void main(String[] args)
throws InterruptedException
{
//定义LinkedBlockingDeque的容量
int capacityOfDeque = 4;
//创建LinkedBlockingDeque对象
LinkedBlockingDeque linkedDeque
= new LinkedBlockingDeque(capacityOfDeque);
//向deque添加元素
linkedDeque.put(85461);
linkedDeque.put(44648);
linkedDeque.put(45654);
//创建一个空的集合
ArrayList add = null;
//尝试将空的deque转移到集合
try {
linkedDeque.drainTo(add);
}
catch (Exception e) {
System.out.println("异常：" + e);
}
}
}
异常：java.lang.NullPointerException
drainTo(Collection<? super E> col, int maxElements)
**drainTo(Collection <? super E> col, int maxElements) ** 用于将传递给drainTo()的整数数量的元素转移至作为参数传递给该方法的集合。转移元素后，LinkedBlockingDeque仅包含未转移至集合的元素。该函数与上面的函数相同，但具有一些限制，以传输固定数量的元素。
语法：
public int drainTo(Collection<E> col, int maxElements)
参数： 该方法接受两个参数：
- col – 表示要从LinkedBlockingDeque转移元素的集合。
- maxElements – 这是整数类型，并引用要传输到集合中的最大元素数。
返回值： 该方法返回从deque到集合中排出的元素数。
异常： 该方法会抛出以下异常：
- UnsupportedOperationException – 如果集合无法添加元素。
- ClassCastException – 如果元素的类阻止方法向集合添加元素。
- NullPointerException – 如果集合为空
- IllegalArgumentException – 如果方法的参数阻止将其添加到指定集合中
下面的程序演示了LinkedBlockingDeque类的drainTo(Collection<? super E> col，int maxElements)方法：
程序1：
下面的程序有一个LinkedBlockingDeque，它存储Employee对象，并且有一个HashSet，其中将从LinkedBlockingDeque存储所有Employee对象。所以使用LinkedBlockingDeque的drainTo()将一些Employee从deque传递到ArrayList中。因此，要转移的元素数量作为参数传递给该方法。
// Java程序演示 drainTo() 方法
//来自LinkedBlockingDeque。
import java.util.*;
import java.util.concurrent.LinkedBlockingDeque;
public class GFG {
// 创建一个员工对象，包括职位和工资属性
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 + "]";
}
}
// 主要方法
public static void main(String[] args)
{
GFG gfg = new GFG();
gfg.containsMethodExample();
}
public void containsMethodExample()
{
// 定义LinkedBlockingDeque的容量
int capacity = 10;
// 创建LinkedBlockingDeque的对象
LinkedBlockingDeque<Employee> linkedDeque
= new LinkedBlockingDeque<Employee>(capacity);
// 创建一个HashSet，用作drainTo() 的参数
HashSet<Employee> collection
= new HashSet<Employee>();
// 将Employee对象添加到deque
Employee emp1 = new Employee("Sachin",
"分析师",
"40000");
Employee emp2 = new Employee("Aman",
"开发人员",
"69000");
Employee emp3 = new Employee("Kajal",
"会计",
"39000");
linkedDeque.add(emp1);
linkedDeque.add(emp2);
linkedDeque.add(emp3);
// 在应用drainTo() 方法之前打印Arraylist和deque
System.out.println("在drainTo()应用之前:");
System.out.println("Deque中的元素数量为 "
+ linkedDeque.size());
System.out.println("Deque中的元素如下");
Iterator<Employee> listOfemp
= linkedDeque.iterator();
while (listOfemp.hasNext())
System.out.println(listOfemp.next());
System.out.println("HashSet中的元素数量为 "
+ collection.size());
System.out.println("HashSet中的元素如下:");
for (Employee emp : collection)
System.out.println(emp);
// 使用drainTo()方法初始化传递给集合的元素数
int noOfElement = 2;
// 应用drainTo方法并将collection作为参数传递
int response
= linkedDeque.drainTo(collection, noOfElement);
// 打印传递的元素数量
System.out.println("\n传递的元素数量: "
+ response);
// 在应用drainTo()方法之后打印Arraylist和deque
System.out.println("\n在drainTo()应用之后:");
System.out.println("Deque中的元素数量为 "
+ linkedDeque.size());
System.out.println("Deque中的元素如下");
listOfemp = linkedDeque.iterator();
while (listOfemp.hasNext())
System.out.println(listOfemp.next());
System.out.println("HashSet中的元素数量为 "
+ collection.size());
System.out.println("HashSet中的元素如下:");
for (Employee emp : collection)
System.out.println(emp);
}
}
在 drainTo() 之前：
Deque 中有 3 个元素
Deque 中的元素如下
Employee [name=Sachin, position=Analyst, salary=40000]
Employee [name=Aman, position=Developer, salary=69000]
Employee [name=Kajal, position=Accountant, salary=39000]
HashSet 中没有元素
传递的元素数量：2
在 drainTo() 之后：
Deque 中有 1 个元素
Deque 中的元素如下
Employee [name=Kajal, position=Accountant, salary=39000]
HashSet 中有 2 个元素
HashSet 中的元素如下：
Employee [name=Sachin, position=Analyst, salary=40000]
Employee [name=Aman, position=Developer, salary=69000]