Método ConcurrentLinkedDeque toArray() en Java con ejemplo

aArray()

El método Java.util.concurrent.ConcurrentLinkedDeque.toArray() devuelve una array que contiene todos los elementos de la deque en la secuencia adecuada, es decir, del primero al último. La array devuelta estará segura a medida que se crea una nueva array (por lo tanto, se asigna nueva memoria). Por lo tanto, la persona que llama es libre de modificar la array. Actúa como un puente entre las API basadas en arreglos y las basadas en colecciones.

Sintaxis

public Object[] toArray()

Parámetros: No toma ningún parámetro.

Valor devuelto: Devuelve una array que contiene todos los elementos de la deque.

Los siguientes ejemplos ilustran el método ConcurrentLinkedDeque.toArray():

Ejemplo 1:

// Java Program Demonstrate toArray()
// method of ConcurrentLinkedDeque
  
import java.util.concurrent.*;
import java.util.*;
  
public class GFG {
    public static void main(String[] args)
        throws IllegalStateException
    {
  
        // create object of ConcurrentLinkedDeque
        ConcurrentLinkedDeque<Integer> deque
            = new ConcurrentLinkedDeque<Integer>();
  
        // Add numbers to end of ConcurrentLinkedDeque
        deque.add(7855642);
        deque.add(35658786);
        deque.add(5278367);
        deque.add(74381793);
  
        System.out.println("ConcurrentLinkedDeque: "
                           + deque);
  
        Object[] a = deque.toArray();
        System.out.println("Returned Array: "
                           + Arrays.toString(a));
    }
}

Producción:

ConcurrentLinkedDeque: [7855642, 35658786, 5278367, 74381793]
Returned Array: [7855642, 35658786, 5278367, 74381793]

aArray(T[])

El método toArray(arr[]) de la clase ConcurrentLinkedDeque en Java se utiliza para formar una array de los mismos elementos que la de ConcurrentLinkedDeque. Devuelve una array que contiene todos los elementos de este ConcurrentLinkedDeque en el orden correcto; el tipo de tiempo de ejecución de la array devuelta es el de la array especificada. Si ConcurrentLinkedDeque cabe en la array especificada, se devuelve allí. De lo contrario, se asigna una nueva array con el tipo de tiempo de ejecución de la array especificada y el tamaño de este ConcurrentLinkedDeque.
Si ConcurrentLinkedDeque cabe en la array especificada con espacio de sobra (es decir, la array tiene más elementos que ConcurrentLinkedDeque), el elemento de la array que sigue inmediatamente al final de ConcurrentLinkedDeque es deque a nulo. (Esto es útil para determinar la longitud de ConcurrentLinkedDeque solo si la persona que llama sabe que ConcurrentLinkedDeque no contiene ningún elemento nulo).

Sintaxis:

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

Parámetros: el método acepta un parámetro arr[] que es la array en la que se almacenarán los elementos de ConcurrentLinkedDeque, si es lo suficientemente grande; de lo contrario, se asigna una nueva array del mismo tipo de tiempo de ejecución para este propósito.

Valor devuelto: el método devuelve una array que contiene elementos similares a ConcurrentLinkedDeque.

Excepción: el método puede generar dos tipos de excepción:

ArrayStoreException : cuando la array mencionada es de un tipo diferente y no se puede comparar con los elementos mencionados en ConcurrentLinkedDeque.
NullPointerException : si la array es nula, se lanza esta excepción.

El siguiente programa ilustra el funcionamiento del método ConcurrentLinkedDeque.toArray(arr[]).

Programa 1: cuando la array tiene el tamaño de ConcurrentLinkedDeque

// Java code to illustrate toArray(arr[])
  
import java.util.concurrent.*;
import java.util.*;
  
public class ConcurrentLinkedDequeDemo {
    public static void main(String args[])
    {
        // Creating an empty ConcurrentLinkedDeque
        ConcurrentLinkedDeque<String> deque
            = new ConcurrentLinkedDeque<String>();
  
        // Use add() method to add
        // elements into the ConcurrentLinkedDeque
        deque.add("Welcome");
        deque.add("To");
        deque.add("Geeks");
        deque.add("For");
        deque.add("Geeks");
  
        // Displaying the ConcurrentLinkedDeque
        System.out.println("The ConcurrentLinkedDeque: "
                           + deque);
  
        // Creating the array and using toArray()
        String[] arr = new String[5];
        arr = deque.toArray(arr);
  
        // Displaying arr
        System.out.println("Returned Array: "
                           + Arrays.toString(arr));
    }
}

Producción:

The ConcurrentLinkedDeque: [Welcome, To, Geeks, For, Geeks]
Returned Array: [Welcome, To, Geeks, For, Geeks]

Publicación traducida automáticamente

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

aArray()

aArray(T[])

Deja una respuesta Cancelar la respuesta