Java中LinkedTransferQueue的drainTo()方法

drainTo(Collection c)

java.util.concurrent.LinkedTransferQueue类的 drainTo(Collection c) 方法是Java中的一个内置函数，它删除此队列中存在的所有元素并将它们添加到提供的 collection 中。这比重复轮询这个队列更有效率。

当从队列中试图向集合 c 中添加元素时，有可能会遇到失败，并且由于这种失败，在抛出关联异常时元素会在两个集合之间分配。如果尝试将队列的drainTo()转移到队列本身，则会抛出 IllegalArgumentException 异常。如果在操作正在进行时修改了指定的集合，则此操作的行为未定义。因此，对于使用这种方法，需要注意这种类型的情况以克服异常。

语法：

public int drainTo(Collection c)

参数： 该函数接受一个强制参数c，即要转移元素的集合。

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

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

NullPointerException - 如果集合为 null
IllegalArgumentException - 如果方法的参数使其无法添加到指定的集合

以下程序演示了java.util.concurrent.LinkedTransferQueue.drainTo()方法的使用：

程序1： 从队列中排出所有元素到指定的 collection。

// Java Program Demonstrate drainTo()
// method of LinkedTransferQueue
  
import java.util.*;
import java.util.concurrent.LinkedTransferQueue;
  
class GFG {
    public static void main(String[] args)
    {
  
        // Initializing the List
        List<Integer> list = new ArrayList<Integer>();
  
        // Initializing the queue
        LinkedTransferQueue<Integer>
            queue = new LinkedTransferQueue<Integer>();
  
        // Adding elements to this queue
        for (int i = 10; i <= 15; i++)
            queue.add(i);
  
        // Printing the elements of the queue
        System.out.println("Elements in the queue = "
                           + queue);
  
        // drainTo() method removes all available elements
        // from this queue and adds them to the list
        queue.drainTo(list);
  
        // Printing the elements of the queue after drainTo()
        System.out.println("Elements left in the queue :"
                           + queue);
  
        // Printing the elements of the list
        System.out.println("Elements drained in the list :"
                           + list);
    }
}

Elements in the queue = [10, 11, 12, 13, 14, 15]
Elements left in the queue :[]
Elements drained in the list :[10, 11, 12, 13, 14, 15]

程序2： 演示灌注(NullPointerException)。

// Java程序演示了LinkedTransferQueue类中的drainTo()方法
  
import java.util.ArrayList;
import java.util.concurrent.LinkedTransferQueue;
  
class GFG {
    public static void main(String[] args)
        throws InterruptedException
    {
  
        // 初始化队列
        LinkedTransferQueue<Integer>
            queue = new LinkedTransferQueue<Integer>();
  
        // 将元素添加到队列中
        queue.put(10);
        queue.put(20);
        queue.put(30);
  
        // 创建一个空的集合
        ArrayList<Integer> add = null;
  
        // 尝试将空队列转移到集合中
        try {
            // 由于add列表为空，这将抛出异常
            queue.drainTo(add);
        }
        catch (Exception e) {
            System.out.println("异常: " + e);
        }
    }
}

异常: java.lang.NullPointerException

drainTo(Collection c, int maxElements)

java.util.concurrent.LinkedTransferQueue 中的 drainTo(Collection c, int maxElements) 方法是Java中的一种内置函数，用于将指定数量的元素传输到传递给方法的集合中。传输元素后，LinkedTransferQueue 将只剩下那些未传输到集合中的元素。此函数与上面的函数相同，具有一些限制来传输固定数量的元素。

语法:

public int drainTo(Collection c,
          int maxElements)

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

c – 表示从LinkedTransferQueue中传输元素的集合。
maxElements – 这是整数类型，并且指的是要传输到集合中的最大元素数。

返回值： 该函数返回从队列中传到集合的元素数量。

异常： 该方法会抛出以下异常:

* **NullPointerException** \- 如果集合为空。 
* **IllegalArgumentException** \- 如果该方法的参数阻止将它添加到指定集合中。

程序1： 从队列中最多提取给定数量的可用元素到指定集合的程序。

// Java程序演示LinkedTransferQueue的drainTo()方法
  
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.LinkedTransferQueue;
  
class GFG {
    public static void main(String[] args)
    {
  
        // 初始化列表
        List<Integer> list = new ArrayList<Integer>();
  
        // 初始化队列
        LinkedTransferQueue<Integer>
            queue = new LinkedTransferQueue<Integer>();
  
        // 将元素添加到该队列中
        for (int i = 1; i <= 10; i++)
            queue.add(i);
  
        // 打印队列元素
        System.out.println("队列中的元素 = " + queue);
  
        // drainTo()方法最多移除指定数量的可用元素
        // 从队列中取出，并将它们加到列表中。
        queue.drainTo(list, 5);
  
        // 输出drainTo()方法后队列中的元素
        System.out.println("队列中剩余的元素：" + queue);
  
        // 打印列表中的元素
        System.out.println("列表中抽出的元素：" + list);
    }
}

输出:

队列中的元素 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
队列中剩余的元素：[6, 7, 8, 9, 10]
列表中抽出的元素：[1, 2, 3, 4, 5]

程序2: 演示drainTo()中NullPointerException的程序。

// Java程序演示LinkedTransferQueue的drainTo()方法
  
import java.util.ArrayList;
import java.util.concurrent.LinkedTransferQueue;
  
class GFG {
    public static void main(String[] args)
        throws InterruptedException
    {
  
        // 初始化队列
        LinkedTransferQueue<Integer> queue
            = new LinkedTransferQueue<Integer>();
  
        // 添加元素到队列中
        queue.put(10);
        queue.put(20);
        queue.put(30);
  
        // 创建一个值为空的集合。
        ArrayList<Integer> add = null;
  
        // 尝试从null队列中取元素到集合中
        try {
            // 这将抛出异常，因为add列表为空值
            queue.drainTo(add, 2);
        }
        catch (Exception e) {
            System.out.println("异常:" + e);
        }
    }
}

输出:

异常: java.lang.NullPointerException

参考:

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/LinkedTransferQueue.html#drainTo(java.util.Collection)
[https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/LinkedTransferQueue.html#drainTo(java.util.Collection,%20int)](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/LinkedTransferQueue.html#drainTo(java.util.Collection, %20int))