Cómo convertir una matriz de Java a ArrayList

Introducción

En este tutorial, convertiremos una matriz en una ArrayList más versátil en Java.

• Arrays.asList ()
• new ArrayList <> (Arrays.asList ()) (enfoque más popular y utilizado)
• new ArrayList <> (List.of ())
• Colecciones.addAll ()
• Collectors.toList ()
• Collectors.toCollection ()
• Lists.newArrayList ()

Las matrices son simples y proporcionan la funcionalidad básica de agrupar una colección de objetos o tipos de datos primitivos. Sin embargo, las matrices también son limitadas: su tamaño es fijo e incluso las operaciones básicas como agregar nuevos elementos al principio o reorganizar elementos pueden complicarse.

Afortunadamente, el marco de colecciones nos presentó muchas implementaciones muy útiles de Lists, Sets, y Queues.

Uno de estos es el ArrayList, una implementación muy versátil y popular de un List.

Un ArrayListEl constructor aceptará cualquier Collection. Podemos ser creativos con el tipo de colección que le pasamos.

Arrays.asList ()

Comencemos con la forma más simple de conversión. los Arrays helper class tiene muchos métodos útiles. los asList() método devuelve el contenido de la matriz en un List:

Employee emp1 = new Employee("John");
Employee emp2 = new Employee("Sarah");
Employee emp3 = new Employee("Lily");

Employee[] array = new Employee[]{emp1, emp2, emp3};

List<Employee> list = Arrays.asList(array);
System.out.println(list);

Esto resultará en una List implementación (ArrayList) para ser poblado con emp1, emp2 y emp3. Ejecutar este código da como resultado:

[Employee{name="John"}, Employee{name="Sarah"}, Employee{name="Lily"}]

new ArrayList <> (Arrays.asList ())

Un enfoque mejor que simplemente asignar el valor de retorno del método auxiliar es pasar el valor de retorno a un new ArrayList<>(). Esta es el enfoque estándar utilizado por la mayoría de las personas.

Esto es porque el asList() El método está respaldado por la matriz original.

Si cambia la matriz original, la lista también cambiará. También, asList() devuelve un tamaño fijo, ya que está respaldado por la matriz fija. Las operaciones que ampliarían o reducirían la lista devolverían un UnsupportedOperationException.

Para evitarlos, aplicaremos las características de un ArrayList pasando el valor devuelto de asList() al constructor:

Employee[] array = new Employee[]{emp1, emp2, emp3};

List<Employee> list = new ArrayList<>(Arrays.asList(array));
System.out.println(list);

Esto resulta en:

[Employee{name="John"}, Employee{name="Sarah"}, Employee{name="Lily"}]

new ArrayList <> (List.of ())

Desde Java 9, puede omitir la inicialización de una matriz y pasarla al constructor. Puedes usar List.of() y pasar elementos individuales:

List<Employee> list = new ArrayList<>(List.of(emp1, emp2, emp3));
System.out.println(list);

Esto resulta en:

[Employee{name="John"}, Employee{name="Sarah"}, Employee{name="Lily"}]

Colecciones.addAll ()

los Collections ofrece una miríada de métodos de ayuda útiles y entre ellos se encuentra el addAll() método. Acepta un Collection y un vararg de elements y los une.

Es muy versátil y se puede usar con muchos sabores de colección / vararg. Estamos usando un ArrayList y una matriz:

Employee[] array = new Employee[]{emp1, emp2, emp3};
List<Employee> list = new ArrayList<>();

Collections.addAll(list, array);
System.out.println(list);

Esto resulta en:

[Employee{name="John"}, Employee{name="Sarah"}, Employee{name="Lily"}]

Collectors.toList ()

Si está trabajando con transmisiones, en lugar de colecciones regulares, puede recopilar los elementos de la transmisión y empaquetarlos en una lista a través de toList():

Employee[] array = new Employee[]{emp1, emp2, emp3};
List<Employee> list = Stream.of(array).collect(Collectors.toList());
System.out.println(list);

Ejecutar esto producirá:

[Employee{name="John"}, Employee{name="Sarah"}, Employee{name="Lily"}]

Collectors.toCollection ()

Del mismo modo, puede utilizar el toCollection() método para recopilar corrientes en diferentes colecciones. En nuestro caso, proporcionaremos el ArrayList::new referencia de método en él, aunque también puede proporcionar otras referencias:

Employee[] array = new Employee[]{emp1, emp2, emp3};
List<Employee> list =  Stream.of(array)
        .collect(Collectors.toCollection(ArrayList::new));
System.out.println(list);

Esto también resulta en:

[Employee{name="John"}, Employee{name="Sarah"}, Employee{name="Lily"}]

Lists.newArrayList ()

Similar a Arrays.asList() clase y método de ayuda, de Google Guayaba proyecto nos introdujo a la Lists clase de ayudante. los Lists la clase auxiliar proporciona el newArrayList() método:

Employee[] array = new Employee[]{emp1, emp2, emp3};
List<Employee> list = Lists.newArrayList(array);

Ahora, el punto clave de este enfoque fue que no es necesario especificar el tipo al inicializar un ArrayList. Esto fue realmente útil cuando tenías un <Element <Element, Element>> lista.

Sin embargo, como Java 7 eliminó la necesidad de establecer explícitamente el tipo en el operador de diamante, esto se volvió obsoleto.

Conclusión

Hay numerosas formas de convertir una matriz en una ArrayList en Java. Estos abarcan desde llamar a métodos auxiliares hasta transmitir la matriz y recopilar los elementos.