Conversión de ArrayList a Array en Java: Métodos toArray()

Se pueden usar los siguientes métodos para convertir ArrayList a Array:
 

Método 1: usar el método Object[] toArray()

Sintaxis: 
 

 public Object[] toArray() 

• Está especificado por toArray en la colección de interfaz y la lista de interfaz
• Anula toArray en la clase AbstractCollection
• Devuelve una array que contiene todos los elementos de esta lista en el orden correcto.

// Java program to demonstrate working of
// Objectp[] toArray()
import java.io.*;
import java.util.List;
import java.util.ArrayList;
  
class GFG {
    public static void main(String[] args)
    {
        List<Integer> al = new ArrayList<Integer>();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(40);
  
        Object[] objects = al.toArray();
  
        // Printing array of objects
        for (Object obj : objects)
            System.out.print(obj + " ");
    }
}

10 20 30 40 

Nota: el método toArray() devuelve una array de tipo Object(Object[]). Necesitamos encasillarlo en Integer antes de usarlo como objetos Integer. Si no encasillamos, obtenemos un error de compilación. Considere el siguiente ejemplo: 
 

// A Java program to demonstrate that assigning Objects[]
// to Integer[] causes error.
import java.io.*;
import java.util.List;
import java.util.ArrayList;
  
class GFG {
    public static void main(String[] args)
    {
        List<Integer> al = new ArrayList<Integer>();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(40);
  
        // Error: incompatible types: Object[]
        // cannot be converted to Integer[]
        Integer[] objects = al.toArray();
  
        for (Integer obj : objects)
            System.out.println(obj);
    }
}

Producción: 

19: error: incompatible types: Object[] cannot be converted to Integer[]
        Integer[] objects = al.toArray(); 
                                      ^
1 error

Por lo tanto, se recomienda crear una array en la que se deben almacenar los elementos de List y pasarla como argumento en el método toArray() para almacenar elementos si es lo suficientemente grande. De lo contrario, se asigna una nueva array del mismo tipo para este propósito.
 

Método 2: Usando T[] toArray(T[] a)

// Converts a list into an array arr[] and returns same. 
// If arr[] is not big enough, then a new array of same
// type is allocated for this purpose.
// T represents generic.
public  T[] toArray(T[] arr)

Tenga en cuenta que hay un parámetro de array y un valor de retorno de array. El objetivo principal de la array pasada es indicar el tipo de array. La array devuelta es del mismo tipo que la array pasada. 
 

• Si la array pasada tiene suficiente espacio, los elementos se almacenan en esta array.
• Si la array pasada no tiene suficiente espacio, se crea una nueva array con el mismo tipo y tamaño de la lista dada.
• Si la array pasada tiene más espacio, la array se llena primero con elementos de la lista y luego se llenan los valores nulos.

Lanza ArrayStoreException si el tipo de tiempo de ejecución de a no es un supertipo del tipo de tiempo de ejecución de cada elemento de esta lista.
 

// A Java program to convert an ArrayList to arr[]
import java.io.*;
import java.util.List;
import java.util.ArrayList;
  
class GFG {
    public static void main(String[] args)
    {
        List<Integer> al = new ArrayList<Integer>();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(40);
  
        Integer[] arr = new Integer[al.size()];
        arr = al.toArray(arr);
  
        for (Integer x : arr)
            System.out.print(x + " ");
    }
}

10 20 30 40 

Nota: si la array especificada es nula, arrojará NullpointerException. Vea esto por ejemplo.
 

Método 3: Método manual para convertir ArrayList usando el método get()

Podemos usar este método si no queremos usar java en el método integrado toArray(). Este es un método manual para copiar todos los elementos de ArrayList a String Array[]. 

// Returns the element at the specified index in the list.
public E get(int index)

// Java program to convert a ArrayList to an array
// using get() in a loop.
import java.io.*;
import java.util.List;
import java.util.ArrayList;
  
class GFG {
    public static void main(String[] args)
    {
        List<Integer> al = new ArrayList<Integer>();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(40);
  
        Integer[] arr = new Integer[al.size()];
  
        // ArrayList to Array Conversion
        for (int i = 0; i < al.size(); i++)
            arr[i] = al.get(i);
  
        for (Integer x : arr)
            System.out.print(x + " ");
    }
}

10 20 30 40 

Método 4: usar la API de flujos de colecciones en Java 8 para convertir a una array de tipo int primitivo

Podemos usar este método streams() de lista y mapToInt() para convertir ArrayList<Integer> en una array de tipo de datos primitivo int

int[] arr = list.stream().mapToInt(i -> i).toArray();

// Java program to convert a ArrayList to an array
  
// using streams()
  
import java.io.*;
import java.util.List;
import java.util.ArrayList;
  
class GFG {
    public static void main(String[] args)
    {
        List<Integer> al = new ArrayList<Integer>();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(40);
  
        // ArrayList to Array Conversion
        int[] arr = al.stream().mapToInt(i -> i).toArray();
  
        for (int x : arr)
            System.out.print(x + " ");
    }
}

10 20 30 40 

Referencia:  
http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html#toArray()
Este artículo es una contribución de Nitsdheerendra . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.