La conversión de serie a la lista en Java

Question

¿Cómo se convierte una matriz a una lista en Java?

He utilizado el Arrays.asList() pero el comportamiento (y firma) de alguna manera cambiado de Java SE 1.4.2 (docs ahora en el archivo) a 8 y la mayoría de los fragmentos que he encontrado en el uso de la web el comportamiento 1.4.2.

Por ejemplo:

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

• en 1.4.2 Devuelve una lista con los elementos 1, 2, 3
• en 1.5.0+ devuelve una lista que contiene el correo no deseado array

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

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

Answer 1

En el ejemplo, es porque no se puede tener una lista de un tipo primitivo. En otras palabras, List<int> no es posible.

Puede, sin embargo, tener un List<Integer> utilizando el Integer clase que envuelve el int primitiva. Convertir su matriz a un List con el Arrays.asList método de utilidad.

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

ejecutar en vivo en IdeOne.com .

Answer 2

En Java 8, puede utilizar secuencias:

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

Answer 3

Hablando de manera conversión, que depende de la razón por qué necesita su List. Si lo necesita sólo para leer datos. OK, aquí van:

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

Pero si haces algo como esto:

list.add(1);

se obtiene java.lang.UnsupportedOperationException. Así que para algunos casos incluso se necesita lo siguiente:

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

En primer enfoque realidad no convierte matriz, pero 'representa' como si fuera un List. Pero matriz es bajo el capó con todas sus propiedades, como el número fijo de elementos. Tenga en cuenta que es necesario especificar el tipo en la construcción de ArrayList.

Answer 4

El problema es que varargs consiguieron introducirse en Java5 y por desgracia, Arrays.asList() consiguieron sobrecargados con una versión vararg también. Así Arrays.asList(spam) se entiende por el compilador Java5 como un parámetro vararg de arrays Int.

Este problema se explica con más detalles en efectivo Java 2ª Ed., Capítulo 7, artículo 42.

Answer 5

Parece poco tarde pero aquí están mis dos centavos. No podemos tener List<int> como int es un tipo primitivo por lo que sólo 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 y por debajo (array entero)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

Necesidad ArrayList y no lista?

En caso de que quieran una implementación específica del List por ejemplo, ArrayList entonces podemos utilizar 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 estática privada definida en el interior java.util.Arrays. Así que si añadir o eliminar elementos de la lista devuelta, se lanzará una UnsupportedOperationException. Así que hay que ir con list22 cuando queremos modificar la lista. Si tenemos Java8 entonces también podemos ir con list23.

Para ser list21 claro puede ser modificado en el sentido de que podemos llamar list21.set(index,element) pero esta lista no puede ser modificado estructuralmente es decir, no se puede añadir o elementos de eliminar de la lista. También puede comprobar esto pregunta .

---

Si queremos una lista inmutable entonces podemos envolverlo como:

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

Otro punto a señalar es que la Collections.unmodifiableList método devuelve una vista no modificable de la lista especificada. Una colección vista inmodificable es una colección que es modificable y es también una vista en una colección de respaldo. Nótese que los cambios a la colección respaldo aún podría ser posible, y si se producen, que son visibles a través de la vista no se puede modificar.

puede tener una lista verdaderamente inmutable en Java 10.

Java 10 (lista de verdad inmutable) de dos maneras:

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

También puedes ver este mío por más.

Answer 6

Recientemente tuve para convertir una matriz a una lista. Más tarde en el programa de filtrado la lista de intentar extraer los datos. Cuando se utiliza la función Arrays.asList (matriz), se crea una colección de tamaño fijo: usted no puede añadir ni eliminar. Esta entrada se explica el problema mejor que puedo: ¿Por qué aparece una UnsupportedOperationException cuando se trata de eliminar un elemento de una lista? .

Al final, que tenía que hacer una conversión "manual":

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

I supongamos que podría haber añadido la conversión de una matriz a una lista que utiliza una (artículos) operación List.addAll.

Answer 7

Incluso más corto:

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

Answer 8

Utilizar matrices

Esta es la forma más sencilla para convertir una matriz para List. Sin embargo, si se intenta añadir un nuevo elemento o eliminar un elemento existente de la lista, se lanzará 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!

Uso de ArrayList o en otra lista Implementaciones

Se puede utilizar un bucle for añadir todos los elementos de la matriz en una implementación List, por ejemplo ArrayList:

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

Uso de la API de corriente en Java 8

Se puede convertir la matriz en una corriente, a continuación, recoger el flujo usando diferentes colectores:. El colector por defecto en Java 8 utilización ArrayList detrás de la pantalla, pero también se 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é usamos autoboxing y unboxing en Java?
• Cuándo utilizar ListaEnlazada sobre ArrayList?

Answer 9

Otra solución si se utiliza Apache Commons-Lang:

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

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

Answer 10

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

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

(descaradamente copiado de aquí )

Answer 11

Si el idioma de Java 8 (o posterior), puede intentar lo siguiente:

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

Nota:

Tenga en cuenta el Collectors.<Integer>toList(), este método genérico le ayuda a evitar el error "No coinciden los tipos: no se puede convertir de List<Object> a List<Integer>".

Answer 12

tiene que echaban a array

Arrays.asList((Object[]) array)

Answer 13

One-liner:

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

Answer 14

1. El uso de guayaba:

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

2. El uso de Apache Commons Colecciones:

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

Answer 15

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<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 16

Si esto ayuda: He tenido el mismo problema y simplemente escribí una función genérica que toma una matriz y devuelve un 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 17

Array Dado:

    int[] givenArray = {2,2,3,3,4,5};

conversión de matriz de enteros a lista de números enteros

Una manera: en caja () -> devuelve el IntStream

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

segunda manera: Mapa de cada elemento de la corriente a entero y luego recoger

Nota: Uso mapToObj puede encubierta cada elemento int en la corriente de cuerdas, etc corriente de carbón por la carcasa i a (char) i

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

conversión de un tipo de matriz con otro ejemplo Tipo:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

Answer 18

utilizar dos líneas de código para convertir matriz a la lista si lo usa en valor entero debe utilizar el tipo autoboxing para el tipo de datos primitivo

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