Cómo convertir una matriz Java a ArrayList

En este tutorial, repasaremos muchos ejemplos de cómo convertir una matriz de Java en una ArrayList, señalando las mejores prácticas.

Introducción

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

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 están limitadas: su tamaño es fijo e incluso las operaciones básicas, como agregar nuevos elementos al principio o reorganizar elementos, pueden complicarse.

Afortunadamente, Collections Framework nos presentó muchas implementaciones muy útiles de Lists, Sets y Queues.

Uno de ellos es ArrayList, una implementación realmente versátil y popular de List.

El constructor de una ArrayList aceptará cualquier Colección. Podemos ser creativos con el tipo de colección que le pasamos.

Matrices.asList()

Comencemos con la forma más simple de conversión. La clase auxiliar Arrays tiene muchos métodos útiles. El método asList() devuelve el contenido de la matriz en una Lista:

1
2
3
4
5
6
7
8
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 dará como resultado una implementación de Lista (ArrayList) que se completará con emp1, emp2 y emp3. Ejecutar este código da como resultado:

1
[Employee{name='John'}, Employee{name='Sarah'}, Employee{name='Lily'}]

new ArrayList<>(Arrays.asList())

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

Esto se debe a que el método asList() está respaldado por la matriz original.

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

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

1
2
3
4
Employee[] array = new Employee[]{emp1, emp2, emp3};

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

Esto resulta en:

1
[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:

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

Esto resulta en:

1
[Employee{name='John'}, Employee{name='Sarah'}, Employee{name='Lily'}]

Colecciones.addAll()

La clase Collections ofrece una miríada de útiles métodos auxiliares y entre ellos se encuentra el método addAll(). Acepta una Colección y un vararg de elementos y los une.

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

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

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

Esto resulta en:

1
[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():

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

Ejecutar esto producirá:

1
[Employee{name='John'}, Employee{name='Sarah'}, Employee{name='Lily'}]

Coleccionistas.aColección()

De manera similar, puede usar el método toCollection() para recopilar flujos en diferentes colecciones. En nuestro caso, proporcionaremos ArrayList::new referencia del método, aunque también podría proporcionar otras referencias:

1
2
3
4
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:

1
[Employee{name='John'}, Employee{name='Sarah'}, Employee{name='Lily'}]

Lists.newArrayList()

Similar a la clase auxiliar y el método Arrays.asList(), el proyecto Guayaba de Google nos presentó la clase auxiliar Lists. La clase auxiliar Lists proporciona el método newArrayList():

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

Ahora, la conclusión clave de este enfoque es que no es necesario especificar el tipo al inicializar una ArrayList. Esto fue realmente útil cuando tenía una lista <Elemento <Elemento, Elemento>>.

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

Conclusión

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

Licensed under CC BY-NC-SA 4.0