Método ConcurrentLinkedQueue toArray() en Java

toArray() : El método toArray() de ConcurrentLinkedQueue se usa para devolver una array de los mismos elementos que los de ConcurrentLinkedQueue en la secuencia adecuada. Básicamente, copia todo el elemento de ConcurrentLinkedQueue a una nueva array. Este método se comporta como un puente entre la array y ConcurrentLinkedQueue.

Sintaxis:

public Object[] toArray()

Devoluciones: el método devuelve una array que contiene los elementos similares a ConcurrentLinkedQueue.

Los siguientes programas ilustran el método java.util.concurrent.ConcurrentLinkedQueue.toArray().

Ejemplo 1:

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

Producción:

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

Ejemplo 2:

// Java Program Demonstrate toArray()
// method of ConcurrentLinkedQueue
  
import java.util.concurrent.ConcurrentLinkedQueue;
  
public class GFG {
    public static void main(String args[])
    {
        // Creating a ConcurrentLinkedQueue
        ConcurrentLinkedQueue<String>
            queue = new ConcurrentLinkedQueue<String>();
  
        // elements into the Queue
        queue.add("Welcome");
        queue.add("To");
        queue.add("Jungle");
  
        // Displaying the ConcurrentLinkedQueue
        System.out.println("The ConcurrentLinkedQueue: "
                           + queue);
  
        // Creating the array and using toArray()
        Object[] arr = queue.toArray();
  
        System.out.println("The array is:");
        for (int j = 0; j < arr.length; j++)
            System.out.println(arr[j]);
    }
}

Producción:

The ConcurrentLinkedQueue: [Welcome, To, Jungle]
The array is:
Welcome
To
Jungle

toArray(T[] a) : El método toArray(T[] a) de ConcurrentLinkedQueue se usa para una array que contiene los mismos elementos que los de esta ConcurrentLinkedQueue 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 ConcurrentLinkedQueue 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 la array como parámetro en el 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.

Devoluciones: este método devuelve una array que contiene los elementos similares a ConcurrentLinkedQueue.

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

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

Los siguientes programas ilustran el método java.util.concurrent.ConcurrentLinkedQueue.toArray(T[] a).

Ejemplo 1:

// Java Program Demonstrate toArray()
// method of ConcurrentLinkedQueue
  
import java.util.concurrent.ConcurrentLinkedQueue;
  
public class GFG {
  
    public static void main(String[] args)
    {
        // create object of ConcurrentLinkedQueue
        ConcurrentLinkedQueue<String> queue
            = new ConcurrentLinkedQueue<String>();
  
        // elements into the Queue
        queue.add("Welcome");
        queue.add("To");
        queue.add("Jungle");
  
        // print queue details
        System.out.println("Queue Contains " + queue);
  
        // the array to pass in toArray()
        // array has size equal to size of ConcurrentLinkedQueue
        String[] passArray = new String[queue.size()];
  
        // Calling toArray(T[] a) method
        Object[] array = queue.toArray(passArray);
  
        // Print elements of passed array
        System.out.println("\nThe array passed :");
        for (String i : passArray) {
            System.out.print(i + " ");
        }
  
        System.out.println();
  
        // Print elements of returned array
        System.out.println("\nThe array returned :");
        for (Object i : array) {
            System.out.print(i + " ");
        }
    }
}

Producción:

Queue Contains [Welcome, To, Jungle]

The array passed :
Welcome To Jungle 

The array returned :
Welcome To Jungle

Ejemplo 2: Para mostrar ArrayStoreException

// Java Program Demonstrate toArray()
// method of ConcurrentLinkedQueue
  
import java.util.concurrent.ConcurrentLinkedQueue;
  
public class GFG {
  
    public static void main(String[] args)
    {
        // create object of ConcurrentLinkedQueue
        ConcurrentLinkedQueue<Integer> queue
            = new ConcurrentLinkedQueue<Integer>();
  
        // Add element to ConcurrentLinkedQueue
        queue.add(2323);
        queue.add(2472);
        queue.add(4235);
        queue.add(1242);
  
        // the array to pass in toArray()
        // array has size equal to size of ConcurrentLinkedQueue
        String[] passArray = new String[queue.size()];
  
        // Calling toArray(T[] a) method
        try {
            Object[] array = queue.toArray(passArray);
        }
        catch (ArrayStoreException e) {
            System.out.println("Exception: " + e);
        }
    }
}

Producción:

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

Ejemplo 2: Para mostrar NullPointerException

// Java Program Demonstrate toArray()
// method of ConcurrentLinkedQueue
  
import java.util.concurrent.ConcurrentLinkedQueue;
  
public class GFG {
  
    public static void main(String[] args)
    {
        // create object of ConcurrentLinkedQueue
        ConcurrentLinkedQueue<Integer> queue
            = new ConcurrentLinkedQueue<Integer>();
  
        // Add element to ConcurrentLinkedQueue
        queue.add(2323);
        queue.add(2472);
        queue.add(4235);
        queue.add(1242);
  
        // the array to pass
        String[] passArray = null;
  
        // Calling toArray(T[] a) method
        try {
            Object[] array = queue.toArray(passArray);
        }
        catch (NullPointerException e) {
            System.out.println("Exception: " + e);
        }
    }
}

Producción:

Exception: java.lang.NullPointerException

Publicación traducida automáticamente

Artículo escrito por AmanSingh2210 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta