Java中的LinkedTransferQueue drainTo() 方法

drainTo(集合 c)

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

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

句法：

public int drainTo(Collection c)

参数：该函数接受一个强制参数c ，它是元素要传输到的集合。

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

异常：此方法引发以下异常：

• NullPointerException – 如果集合为空
• IllegalArgumentException – 如果方法的参数阻止它被添加到指定的集合中

下面的程序说明了Java.util.concurrent.LinkedTransferQueue.drainTo() 方法的使用：

程序 1：程序将队列中的所有元素排空到指定集合。

// 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 list = new ArrayList();
  
        // Initializing the queue
        LinkedTransferQueue
            queue = new LinkedTransferQueue();
  
        // 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：在 drainTo() 中显示 NullPointerException 的程序。

// Java Program Demonstrate drainTo()
// method of LinkedTransferQueue
  
import java.util.ArrayList;
import java.util.concurrent.LinkedTransferQueue;
  
class GFG {
    public static void main(String[] args)
        throws InterruptedException
    {
  
        // Initializing the queue
        LinkedTransferQueue
            queue = new LinkedTransferQueue();
  
        // add elements to queue
        queue.put(10);
        queue.put(20);
        queue.put(30);
  
        // create a collection with null
        ArrayList add = null;
  
        // try to drain null queue to collection
        try {
            // this will throw exception
            // as the add list is null
            queue.drainTo(add);
        }
        catch (Exception e) {
            System.out.println("Exception: " + e);
        }
    }
}

输出：

Exception: java.lang.NullPointerException

drainTo（集合 c，int maxElements）

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

句法：

public int drainTo(Collection c,
          int maxElements)

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

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

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

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

  • NullPointerException – 如果集合为空
  • IllegalArgumentException – 如果方法的参数阻止它被添加到指定的集合中

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

  // Java Program Demonstrate drainTo()
  // method of LinkedTransferQueue
    
  import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.LinkedTransferQueue;
    
  class GFG {
      public static void main(String[] args)
      {
    
          // Initializing the List
          List list = new ArrayList();
    
          // Initializing the queue
          LinkedTransferQueue
              queue = new LinkedTransferQueue();
    
          // Adding elements to this queue
          for (int i = 1; i <= 10; i++)
              queue.add(i);
    
          // Printing the elements of the queue
          System.out.println("Elements in the queue = "
                             + queue);
    
          // drainTo() method removes at most
          // the given number of available elements
          // from this queue and adds them to the list.
          queue.drainTo(list, 5);
    
          // 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 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  Elements left in the queue :[6, 7, 8, 9, 10]
  Elements drained in the list :[1, 2, 3, 4, 5]
  

  程序 2：在 drainTo() 中显示 NullPointerException 的程序。

  // Java Program Demonstrate drainTo()
  // method of LinkedTransferQueue
    
  import java.util.ArrayList;
  import java.util.concurrent.LinkedTransferQueue;
    
  class GFG {
      public static void main(String[] args)
          throws InterruptedException
      {
    
          // Initializing the queue
          LinkedTransferQueue
              queue = new LinkedTransferQueue();
    
          // add elements to queue
          queue.put(10);
          queue.put(20);
          queue.put(30);
    
          // create a collection with null
          ArrayList add = null;
    
          // try to drain null queue to collection
          try {
              // this will throw exception
              // as the add list is null
              queue.drainTo(add, 2);
          }
          catch (Exception e) {
              System.out.println("Exception: " + e);
          }
      }
  }
  

  输出：

  Exception: java.lang.NullPointerException
  

  参考：

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