Pregunta Conversión de matriz a lista en Java


¿Cómo convierto una matriz a una lista en Java?

Usé el Arrays.asList() pero el comportamiento (y la firma) de alguna manera cambió desde Java SE 1.4.2 (documentos ahora en archivo) para 8 y la mayoría de los fragmentos que encontré en la web usan el comportamiento 1.4.2.

Por ejemplo:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)
  • en 1.4.2 devuelve una lista que contiene los elementos 1, 2, 3
  • en 1.5.0+ devuelve una lista que contiene el conjunto de mensajes no deseados

En muchos casos, debería ser fácil de detectar, pero a veces puede pasar inadvertido:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);

752
2018-04-09 12:20


origen


Respuestas:


En su ejemplo, es porque no puede tener una Lista de un tipo primitivo. En otras palabras, List<int> no es posible. Sin embargo, puedes tener un List<Integer>.

Integer[] spam = new Integer[] { 1, 2, 3 };
Arrays.asList(spam);

Eso funciona como se esperaba


1100
2018-04-09 12:27



El problema es que varargs se introdujo en Java5 y, desafortunadamente, Arrays.asList() se sobrecargó con una versión vararg también. Asi que Arrays.asList(spam) se entiende por el compilador Java5 como un parámetro vararg de matrices int.

Este problema se explica con más detalles en Effective Java 2nd Ed., Chapter 7, Item 42.


111
2018-04-09 12:26



Hablando de la forma de conversión, depende de por qué necesita su List. Si lo necesitas solo para leer datos. OK aquí tienes:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

Pero luego, si haces algo como esto:

list.add(1);

usted obtiene java.lang.UnsupportedOperationException. Entonces, en algunos casos, incluso necesitas esto:

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

El primer enfoque en realidad no convierte matriz pero la "representa" como una List. Pero array está bajo el capó con todas sus propiedades, como la cantidad fija de elementos. Tenga en cuenta que necesita especificar el tipo al construir ArrayList.


105
2017-09-27 16:22



En Java 8, puedes usar streams:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

93
2018-05-16 23:49



Parece un poco tarde, pero aquí están mis dos centavos. No podemos tener List<int> como int es un tipo primitivo, así que solo podemos tener List<Integer>.

Java 8 (matriz int)

int[] ints = new int[] {1,2,3,4,5};
List<Integer> list11 =Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Java 8 y abajo (matriz de enteros)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // Cannot modify returned list
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

¿Necesita ArrayList y no List?

En caso de que deseemos una implementación específica de List p.ej. ArrayList entonces podemos usar toCollection como:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

Por qué list21 no puede ser modificado estructuralmente?

Cuando usamos Arrays.asList el tamaño de la lista devuelta es fijo porque la lista devuelta no es java.util.ArrayList, pero una clase privada estática definida dentro java.util.Arrays. Entonces, si agregamos o eliminamos elementos de la lista devuelta, UnsupportedOperationException será arrojado. Entonces deberíamos ir con list22 cuando queremos modificar la lista Si tenemos Java8 entonces también podemos ir con list23.

Para ser claro list21 se puede modificar en el sentido de que podemos llamar list21.set(index,element) pero esta lista no puede ser modificada estructuralmente, es decir, no puede agregar o eliminar elementos de la lista. También puedes verificar esto pregunta.

Si queremos una lista inmutable, podemos envolverla como sigue:

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

50
2017-12-23 05:07



Recientemente tuve que convertir una matriz a una lista. Más tarde, el programa filtró la lista intentando eliminar los datos. Cuando utiliza la función Arrays.asList (matriz), crea una colección de tamaño fijo: no puede agregar ni eliminar. Esta entrada explica el problema mejor que yo: ¿Por qué recibo una UnsupportedOperationException cuando intento eliminar un elemento de una lista?.

Al final, tuve que hacer una conversión "manual":

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

Supongo que podría haber agregado la conversión de una matriz a una lista usando una operación List.addAll (items).


8
2017-08-31 17:26



Incluso más corto:

List<Integer> list = Arrays.asList(1, 2, 3, 4);

6
2018-03-17 09:55



Usando matrices

Esta es la forma más sencilla de convertir una matriz a List. Sin embargo, si intenta agregar un nuevo elemento o eliminar un elemento existente de la lista, UnsupportedOperationException será arrojado.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

Usando ArrayList u otras implementaciones de listas

Puedes usar un for bucle para agregar todos los elementos de la matriz en un List implementación, p. ArrayList:

List<Integer> list = new ArrayList<>();
for (int i : new int[]{1, 2, 3}) {
  list.add(i);
}

Usar Stream API en Java 8

Puede convertir el conjunto en una secuencia y luego recopilar la secuencia utilizando diferentes recopiladores: el recopilador predeterminado en Java 8 use ArrayList detrás de la pantalla, pero también puede imponer su implementación preferida.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

Ver también:


3
2018-03-04 22:12



Un trazador de líneas:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});

2
2018-03-11 04:15



En Java 9 tiene la solución aún más elegante de usar listas inmutables a través del nuevo método de fábrica de conveniencia List.of:

List<String> immutableList = List.of("one","two","three");

(descaradamente copiado de aquí )


2
2017-11-28 23:22



  1. Usando Guava:

    Integer[] array = { 1, 2, 3};
    List<Integer> list = Lists.newArrayList(sourceArray);
    
  2. Usando colecciones de Apache Commons:

    Integer[] array = { 1, 2, 3};
    List<Integer> list = new ArrayList<>(6);
    CollectionUtils.addAll(list, array);
    

2
2018-04-02 13:03