Conversión de matriz a lista en Java

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

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 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); 

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

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

Eso funciona como se esperaba

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

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

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 list = Arrays.asList(values); 

Pero luego, si haces algo como esto:

 list.add(1); 

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

 Integer[] values = { 1, 3, 7 }; List list = new ArrayList(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 .

En Java 8, puedes usar streams:

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

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

Java 8 (matriz int)

 int[] ints = new int[] {1,2,3,4,5}; List 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 list21 = Arrays.asList(integers); // Cannot modify returned list List list22 = new ArrayList<>(Arrays.asList(integers)); // good List 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 por ejemplo, ArrayList , podemos usar toCollection como:

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

¿Por qué list21 no se puede modificar 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 . Entonces, si agregamos o eliminamos elementos de la lista devuelta, se lanzará una UnsupportedOperationException . Entonces deberíamos ir con list22 cuando queremos modificar la lista. Si tenemos Java8 entonces también podemos ir con list23 .

Para ser claros, la list21 puede modificarse en el sentido de que podemos llamar a 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 esta pregunta .

Si queremos una lista inmutable, podemos envolverla como sigue:

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

Recientemente tuve que convertir una matriz a una lista. Más tarde, el progtwig 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 bash eliminar un elemento de una lista? .

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

  List items = new ArrayList(); 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).

Incluso más corto:

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

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, se lanzará una UnsupportedOperationException .

 Integer[] existingArray = {1, 2, 3}; List list1 = Arrays.asList(existingArray); List 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 ciclo for para agregar todos los elementos de la matriz en una implementación de List , por ejemplo, ArrayList :

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

Usar Stream API en Java 8

Puede convertir la matriz en una secuencia, luego recostackr la secuencia utilizando diferentes recostackdores: el recostackdor predeterminado en Java 8 usa ArrayList detrás de la pantalla, pero también puede imponer su implementación preferida.

 List 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?

Si tiene como objective Java 8 (o posterior), puede intentar esto:

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

NOTA:

Preste atención a los Collectors.toList() , este método genérico le ayuda a evitar el error “Tipo de discrepancia: no se puede convertir de List a List “.

Un trazador de líneas:

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

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

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

(descaradamente copiado de aquí )

  1. Usando Guava:

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

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

tienes que lanzar en una matriz

 Arrays.asList((Object[]) array) 

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[] en Integer[]

A continuación hay varias maneras de convertir un Array a List en Java:

1- Arrays.asList

 public static List convertArrayToListAsList(String[] names) { List namesLst = Arrays.asList(names); return namesLst; } 

La limitación de usar este método es que devuelve una lista de tamaño fijo. Solo puede leer y sobrescribir sus elementos; sin embargo, si intenta agregar / eliminar elementos de la lista devuelta, obtiene UnsupportedOperationException .

Para generar una lista modificable usando Arrays.aslist () , hazlo así:

 List namesLst = new ArrayList(Arrays.asList(names)); 

2- Java 8

En Java 8, puede usar los métodos de utilidad Arrays.stream () y Collectors.toList () .

 public static List convertArrayToListJava8(String[] names) { List namesLst = Arrays.stream(names).collect(Collectors.toList()); return namesLst; } 

3- Forma tradicional

También puede hacer la conversión manualmente iterando sobre los elementos de la matriz y llenando una lista de arreglos .

 private static List convertArrayToListManually(String[] names) { List namesLst = new ArrayList(); for(String name : names) { namesLst.add(name); } return namesLst; } 

Referencia: Java – Convertir matriz en lista

Por lo tanto, depende de la versión de Java que esté intentando:

Java 7

  Arrays.asList(1, 2, 3); 

O

  final String arr[] = new String[] { "G", "E", "E", "K" }; final List initialList = new ArrayList() {{ 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 list = Arrays.stream(num) .boxed().collect(Collectors.toList()) 

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

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 los mismos contenidos:

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

use dos líneas de código para convertir una matriz a 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);