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);
}
}
Producción:
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);
}
}
}
Producción:
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);
}
}
Producción:
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