El método de drenaje a (Colección <E> c) de DelayQueue elimina todos los elementos disponibles de este DelayQueue y los agrega a la colección dada pasada como parámetro. Este método es más eficiente que sondear repetidamente este DelayQueue.
También hay posibilidades de fracaso. Si un DelayQueue intenta drenar una cola hacia sí mismo, resultará en IllegalArgumentException. Además, el comportamiento de esta operación no está definido si la colección especificada se modifica mientras la operación está en curso.
Sintaxis:
public int drainTo (Collection<E> c)
Parámetros: este método acepta un parámetro c que representa la colección para transferir elementos desde DelayQueue.
Valor devuelto: la función devuelve el número de elementos transferidos.
Excepción: este método arroja las siguientes excepciones:
- UnsupportedOperationException : si la colección no puede agregar elementos.
- ClassCastException : si la clase del elemento detiene el método para agregar el elemento a la colección.
- NullPointerException : si la colección es nula.
- IllegalArgumentException : si los argumentos del método impiden que se agregue a la colección especificada.
Los siguientes programas ilustran el método DelayQueue.drainTo():
Programa 1:
Java
// Java Program Demonstrate DelayQueue drainTo() method import java.util.concurrent.*; import java.util.*; // The DelayObject for DelayQueue // It must implement Delayed and // its getDelay() and compareTo() method class DelayObject implements Delayed { private String name; private long time; // Constructor of DelayObject public DelayObject(String name, long delayTime) { this.name = name; this.time = System.currentTimeMillis() + delayTime; } // Implementing getDelay() method of Delayed @Override public long getDelay(TimeUnit unit) { long diff = time - System.currentTimeMillis(); return unit.convert(diff, TimeUnit.MILLISECONDS); } // Implementing compareTo() method of Delayed @Override public int compareTo(Delayed obj) { if (this.time < ((DelayObject)obj).time) { return -1; } if (this.time > ((DelayObject)obj).time) { return 1; } return 0; } // Implementing toString() method of Delayed @Override public String toString() { return "\n{" + " " + name + ", time=" + time + "}"; } } // Driver Class public class GFG { public static void main(String[] args) throws InterruptedException { // create object of DelayQueue // using DelayQueue() constructor BlockingQueue<DelayObject> DQ = new DelayQueue<DelayObject>(); // Add numbers to end of DelayQueue // using add() method DQ.add(new DelayObject("A", 1)); DQ.add(new DelayObject("B", 2)); DQ.add(new DelayObject("C", 3)); DQ.add(new DelayObject("D", 4)); System.out.println("Before drainTo():"); System.out.println("DelayQueue: " + DQ); // create a ArrayList to pass as parameter to drainTo() ArrayList<DelayObject> array = new ArrayList<DelayObject>(); // Apply drainTo method and pass array as parameter int response = DQ.drainTo(array); // 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("DelayQueue : \n" + DQ); System.out.println("ArrayList : \n" + array); } }
Before drainTo(): DelayQueue: [ { A, time=1546842375114}, { B, time=1546842375115}, { C, time=1546842375116}, { D, time=1546842375117}] No of element passed: 4 After drainTo(): DelayQueue : [] ArrayList : [ { A, time=1546842375114}, { B, time=1546842375115}, { C, time=1546842375116}, { D, time=1546842375117}]
Programa 2 : programa para mostrar la excepción lanzada por el método de drenaje().
Java
// Java Program Demonstrate DelayQueue drainTo() method import java.util.concurrent.*; import java.util.*; // The DelayObject for DelayQueue // It must implement Delayed and // its getDelay() and compareTo() method class DelayObject implements Delayed { private String name; private long time; // Constructor of DelayObject public DelayObject(String name, long delayTime) { this.name = name; this.time = System.currentTimeMillis() + delayTime; } // Implementing getDelay() method of Delayed @Override public long getDelay(TimeUnit unit) { long diff = time - System.currentTimeMillis(); return unit.convert(diff, TimeUnit.MILLISECONDS); } // Implementing compareTo() method of Delayed @Override public int compareTo(Delayed obj) { if (this.time < ((DelayObject)obj).time) { return -1; } if (this.time > ((DelayObject)obj).time) { return 1; } return 0; } // Implementing toString() method of Delayed @Override public String toString() { return "\n{" + " " + name + ", time=" + time + "}"; } } // Driver Class public class GFG { public static void main(String[] args) throws InterruptedException { // create object of DelayQueue // using DelayQueue() constructor BlockingQueue<DelayObject> DQ = new DelayQueue<DelayObject>(); // Add numbers to end of DelayQueue // using add() method DQ.add(new DelayObject("A", 1)); DQ.add(new DelayObject("B", 2)); DQ.add(new DelayObject("C", 3)); DQ.add(new DelayObject("D", 4)); // create a collection with null ArrayList<DelayObject> collection = null; // try to drain null DelayQueue to collection try { DQ.drainTo(collection); } catch (Exception e) { System.out.println("Exception: " + e); } } }
Exception: java.lang.NullPointerException
drenajeA(Colección<E> col, int maxElements)
El método de drenaje (Collection<E> col, int maxElements) elimina como máximo el número dado de elementos disponibles de esta cola y los agrega a la colección dada. Después de transferir los elementos, DelayQueue solo tiene aquellos elementos que no se transfieren a la colección.
Sintaxis:
drainTo(Collection<E> c, int maxElements)
Parámetros: este método acepta dos parámetros: –
- c – Representa la colección para transferir elementos desde DelayQueue.s.
- maxElements : es de tipo entero y se refiere a la cantidad máxima de elementos que se transferirán a la colección.
Valor devuelto: la función devuelve el número de elementos transferidos.
Excepción: este método arroja las siguientes excepciones:
- UnsupportedOperationException : si la colección no puede agregar elementos.
- ClassCastException : si la clase del elemento detiene el método para agregar el elemento a la colección.
- NullPointerException : si la colección es nula.
- IllegalArgumentException : si los argumentos del método impiden que se agregue a la colección especificada.
El siguiente programa ilustra el método de drenaje a (Colección <E> col, int maxElements) de la clase DelayQueue: –
Programa:
Java
// Java Program Demonstrate DelayQueue drainTo() method import java.util.concurrent.*; import java.util.*; // The DelayObject for DelayQueue // It must implement Delayed and // its getDelay() and compareTo() method class DelayObject implements Delayed { private String name; private long time; // Constructor of DelayObject public DelayObject(String name, long delayTime) { this.name = name; this.time = System.currentTimeMillis() + delayTime; } // Implementing getDelay() method of Delayed @Override public long getDelay(TimeUnit unit) { long diff = time - System.currentTimeMillis(); return unit.convert(diff, TimeUnit.MILLISECONDS); } // Implementing compareTo() method of Delayed @Override public int compareTo(Delayed obj) { if (this.time < ((DelayObject)obj).time) { return -1; } if (this.time > ((DelayObject)obj).time) { return 1; } return 0; } // Implementing toString() method of Delayed @Override public String toString() { return "\n{" + " " + name + ", time=" + time + "}"; } } // Driver Class public class GFG { public static void main(String[] args) throws InterruptedException { // create object of DelayQueue // using DelayQueue() constructor BlockingQueue<DelayObject> DQ = new DelayQueue<DelayObject>(); // Add numbers to end of DelayQueue // using add() method DQ.add(new DelayObject("A", 1)); DQ.add(new DelayObject("B", 2)); DQ.add(new DelayObject("C", 3)); DQ.add(new DelayObject("D", 4)); System.out.println("Before drainTo():"); System.out.println("Number of elements in the DelayQueue: " + DQ.size()); System.out.println("DelayQueue: " + DQ); // create a ArrayList to pass as parameter to drainTo() ArrayList<DelayObject> array = new ArrayList<DelayObject>(); // Initialize no of element passed to collection // using drainTo() method int noOfElement = 2; // Apply drainTo method and pass array as parameter int response = DQ.drainTo(array, 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("Number of elements in the DelayQueue: " + DQ.size()); System.out.println("DelayQueue : \n" + DQ); System.out.println("ArrayList : \n" + array); } }
Before drainTo(): Number of elements in the DelayQueue: 4 DelayQueue: [ { A, time=1546842382382}, { B, time=1546842382383}, { C, time=1546842382384}, { D, time=1546842382385}] No of element passed: 2 After drainTo(): Number of elements in the DelayQueue: 2 DelayQueue : [ { C, time=1546842382384}, { D, time=1546842382385}] ArrayList : [ { A, time=1546842382382}, { B, time=1546842382383}]
Publicación traducida automáticamente
Artículo escrito por ProgrammerAnvesh y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA