Método LinkedBlockingQueue toArray() en Java

aArray()

El método toArray de LinkedBlockingQueue se usa para crear una array que tiene los mismos elementos que la de este LinkedBlockingQueue, en la secuencia adecuada. En realidad, este método copia todos los elementos de LinkedBlockingQueue en una nueva array. Este método se comporta como un puente entre la array y LinkedBlockingQueue.

Sintaxis: 

public Object[] toArray()

Valor devuelto: este método devuelve una array que contiene los elementos de LinkedBlockingQueue.

Los siguientes programas ilustran el método toArray() de la clase LinkedBlockingQueue:

Programa 1: 

// Java Program Demonstrate toArray()
// method of LinkedBlockingQueue
 
import java.util.concurrent.LinkedBlockingQueue;
 
public class GFG {
 
    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacityOfQueue = 50;
 
        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<Integer> linkedQueue
            = new LinkedBlockingQueue<Integer>(capacityOfQueue);
 
        // Add element to LinkedBlockingQueue
        linkedQueue.add(2300);
        linkedQueue.add(1322);
        linkedQueue.add(8945);
        linkedQueue.add(6512);
 
        // print linkedQueue details
        System.out.println("Queue Contains "
                           + linkedQueue);
 
        // apply toArray() method on linkedQueue
        Object[] array = linkedQueue.toArray();
 
        // Print elements of array
        System.out.println("The array contains:");
        for (Object i : array) {
            System.out.print(i + "\t");
        }
    }
}

Queue Contains [2300, 1322, 8945, 6512]
The array contains:
2300    1322    8945    6512

Programa 2:

// Java Program Demonstrate toArray()
// method of LinkedBlockingQueue
 
import java.util.concurrent.LinkedBlockingQueue;
 
public class GFG {
    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacityOfQueue = 5;
 
        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<String> linkedQueue
            = new LinkedBlockingQueue<String>(capacityOfQueue);
 
        // Add 5 elements to ArrayBlockingQueue
        linkedQueue.offer("User");
        linkedQueue.offer("Employee");
        linkedQueue.offer("Manager");
        linkedQueue.offer("Analyst");
        linkedQueue.offer("HR");
 
        // apply toArray() method on linkedQueue
        Object[] array = linkedQueue.toArray();
 
        // Print elements of array
        System.out.println("The array contains:");
        for (Object i : array) {
            System.out.print(i + " ");
        }
    }
}

The array contains:
User Employee Manager Analyst HR

aArray(T[] a)

El método toArray(T[] a) de LinkedBlockingQueue se usa para devolver una array que contiene los mismos elementos que el de esta LinkedBlockingQueue, en la secuencia adecuada. Este método se diferencia de toArray() en una sola condición. El tipo de la array devuelta es el mismo que la array pasada en el parámetro si el tamaño de LinkedBlockingQueue es menor o igual que la array pasada. De lo contrario, se asigna una nueva array con el mismo tipo que la array especificada y el tamaño de la array es igual al tamaño de esta cola. Este método se comporta como un puente entre la array y las colecciones.

Sintaxis:  

public <T> T[] toArray(T[] a)

Parámetro: este método toma una array como parámetro en la que se copiarán todos los elementos de la cola si es lo suficientemente grande. De lo contrario, se le asigna una nueva array del mismo tipo de tiempo de ejecución.

Valor devuelto: este método devuelve una array que contiene todos los elementos de esta cola.

Excepción Este método arroja las siguientes excepciones:  

• ArrayStoreException: cuando la array pasada es de un tipo diferente al tipo de elementos de LinkedBlockingQueue.
• NullPointerException: si la array pasada es nula.

Los siguientes programas ilustran el método toArray(T[] a) de la clase LinkedBlockingQueue:

Programa 1  

// Java program to demonstrate
// toArray(T[] a) method
// method of LinkedBlockingQueue
 
import java.util.concurrent.LinkedBlockingQueue;
 
public class GFG {
 
    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacityOfQueue = 10;
 
        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<String> linkedQueue
            = new LinkedBlockingQueue<String>(capacityOfQueue);
 
        // Add 5 elements to ArrayBlockingQueue
        linkedQueue.offer("Sonali");
        linkedQueue.offer("Sonam");
        linkedQueue.offer("Kajal");
        linkedQueue.offer("Komal");
 
        // Print queue
        System.out.println("Queue Contains : " + linkedQueue);
 
        // the array to pass in toArray()
        // array has size equal to size of linkedQueue
        String[] passArray = new String[linkedQueue.size()];
 
        // Calling toArray(T[] a) method
        Object[] array = linkedQueue.toArray(passArray);
 
        // Print elements of passed array
        System.out.println("\nThe array passed :");
        for (Object i : passArray) {
            System.out.print(i + "\t");
        }
 
        System.out.println();
 
        // Print elements of returned array
        System.out.println("\nThe array returned :");
        for (Object i : array) {
            System.out.print(i + "\t");
        }
    }
}

Queue Contains : [Sonali, Sonam, Kajal, Komal]

The array passed :
Sonali    Sonam    Kajal    Komal    

The array returned :
Sonali    Sonam    Kajal    Komal    

Programa 2: pasar un tipo diferente de array en toArray() del tipo de elemento que contiene LinkedBlockingQueue. Por lo tanto, el método toArray() lanzará la excepción ArrayStoreException.

// Java Program Demonstrate
// toArray()
// method Exceptions.
 
import java.util.concurrent.LinkedBlockingQueue;
 
public class GFG {
 
    public static void main(String[] args)
        throws InterruptedException
    {
        // define capacity of LinkedBlockingQueue
        int capacityOfQueue = 4;
 
        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<Integer>
            linkedQueue = new LinkedBlockingQueue<Integer>(capacityOfQueue);
 
        // add elements to queue
        linkedQueue.put(46541);
        linkedQueue.put(44648);
        linkedQueue.put(45654);
 
        // create a array of Strings
        String[] arr = {};
 
        // apply toArray method and Pass array of String
        // as parameter to toArray method
        try {
            // LinkedBlockingQueue has type Integer but we are passing
            // String Type array so toArray method will throw
            // Exception
            String[] array = linkedQueue.toArray(arr);
 
            // print elements of queue
            System.out.println("Items in Queue are " + array);
        }
        catch (Exception e) {
            System.out.println("Exception: " + e);
        }
    }
}

Exception: java.lang.ArrayStoreException: java.lang.Integer

Programa 3: Pasar array nula en toArray(). Por lo tanto, el método toArray() lanzará NullPointerException.

// Java program to demonstrate
// toArray() method Exceptions.
 
import java.util.concurrent.LinkedBlockingQueue;
 
public class GFG {
 
    public static void main(String[] args)
        throws InterruptedException
    {
        // define capacity of LinkedBlockingQueue
        int capacityOfQueue = 4;
 
        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<String>
            linkedQueue = new LinkedBlockingQueue<String>(capacityOfQueue);
 
        // add elements to queue
        linkedQueue.put("aman");
        linkedQueue.put("khan");
        linkedQueue.put("Prakash");
 
        // create a array of Strings
        String[] arr = null;
 
        // apply toArray method and Pass array of String
        // as parameter to toArray method
        try {
 
            /// we are passing array with null values
            String[] array = linkedQueue.toArray(arr);
 
            // print elements of queue
            System.out.println("Items in Queue are " + array);
        }
        catch (Exception e) {
            System.out.println("Exception: " + e);
        }
    }
}

Exception: java.lang.NullPointerException

Referencia: 

• https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/LinkedBlockingQueue.html#toArray–
• https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/LinkedBlockingQueue.html#toArray-T:A-