array - Convertir matriz a lista en Java

list to array java

Question

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

Utilicé Arrays.asList() pero el comportamiento (y la firma) de alguna manera cambió de Java SE 1.4.2 (documentos ahora en archivo) a 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 array spam

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

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

Answer 1

Utilizando matrices

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

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

Puede usar un bucle for para agregar todos los elementos de la matriz en una implementación de List , por ejemplo, ArrayList :

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

Utilizando Stream API en Java 8

Puede convertir la matriz en una secuencia y luego recopilarla utilizando diferentes recopiladores: el recopilador predeterminado en Java 8 usa 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:

• ¿Por qué utilizamos autoboxing y unboxing en Java?
• ¿Cuándo usar LinkedList sobre ArrayList?

Answer 2

1. Utilizando guayaba:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = Lists.newArrayList(sourceArray);

2. Usando las colecciones de Apache Commons:

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

Answer 3

Aún más corto:

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

Answer 4

Depende de la versión de Java que estés intentando

Java 7

 Arrays.asList(1, 2, 3);

O

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

O

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

En java 8

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

Referencia : http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

Answer 5

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

Este problema se explica con más detalles en Effective Java 2nd Ed., Capítulo 7, Artículo 42.

Answer 6

En Java 8, puedes usar streams:

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

Answer 7

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

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

(Copiado descaradamente desde here )

Answer 8

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

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

Eso funciona como se esperaba.

Answer 9

Hablando sobre 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 entonces si haces algo como esto:

list.add(1);

obtienes java.lang.UnsupportedOperationException . Así que para 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 la matriz, sino que la "representa" como una List . Pero la matriz está bajo el capó con todas sus propiedades como un número fijo de elementos. Tenga en cuenta que debe especificar el tipo al construir ArrayList .

Answer 10

Hace poco 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 (array), crea una colección de tamaño fijo: no puede agregar ni eliminar. Esta entrada explica el problema mejor que yo: ¿Por qué obtengo una excepción UnsupportedOperationException al intentar 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 utilizando una operación List.addAll (elementos).

Answer 11

Otra solución si usa apache commons-lang:

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

Donde ArrayUtils.toObject convierte int[] a Integer[]

Answer 12

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

Java 8 (int array)

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

Java 8 e inferior (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

¿Necesitas ArrayList y no enumerar?

En caso de que queramos una implementación específica de List por ejemplo, ArrayList , 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 se corrige porque la lista devuelta no es java.util.ArrayList , sino una clase estática privada definida dentro de java.util.Arrays . Por lo tanto, si agregamos o eliminamos elementos de la lista devuelta, se emitirá una UnsupportedOperationException . Así que deberíamos ir con list22 cuando queremos modificar la lista. Si tenemos Java8 entonces también podemos ir con list23 .

Para que quede claro, list21 puede modificarse en el sentido de que podemos llamar a list21.set(index,element) pero esta lista puede no estar estructuralmente modificada, es decir, no puede agregar o eliminar elementos de la lista. También puedes consultar esta question .

Si queremos una lista inmutable, podemos envolverla como:

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

Otro punto a tener en cuenta es que el método Collections.unmodifiableList devuelve una vista no modificable de la lista especificada. Una colección de vista no modificable es una colección que no se puede modificar y también es una vista de una colección de respaldo. Tenga en cuenta que los cambios en la colección de respaldo podrían seguir siendo posibles, y si se producen, son visibles a través de la vista no modificable.

Podemos tener una lista verdaderamente inmutable en Java 10.

Java 10 (lista Verdaderamente Inmutable) de dos maneras:

1. List.copyOf(Arrays.asList(integers))
2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

También puedes ver esta answer mía para más.

Answer 13

Si está apuntando a Java 8 (o posterior), puede intentar esto:

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

NOTA:

Preste atención a los Collectors.<Integer>toList() , este método genérico le ayuda a evitar el error "No hay coincidencia de tipo: no se puede convertir de List<Object> a List<Integer> ".

Answer 14

Si esto ayuda: he tenido el mismo problema y simplemente escribí una función genérica que toma una matriz y devuelve una ArrayList del mismo tipo con el mismo contenido:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}

Answer 15

Un trazador de líneas:

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

Answer 16

tienes que lanzar a la matriz

Arrays.asList((Object[]) array)

Answer 17

use dos líneas de código para convertir la matriz en una lista, si la usa en un valor entero, debe usar el tipo de autoboxing para el tipo de datos primitivo

  Integer [] arr={1,2};
  Arrays.asList(arr);