Pregunta Crear ArrayList desde array


Tengo una matriz que se inicializa como:

Element[] array = {new Element(1), new Element(2), new Element(3)};

Me gustaría convertir esta matriz en un objeto de la clase ArrayList.

ArrayList<Element> arraylist = ???;

2963
2017-10-01 14:38


origen


Respuestas:


new ArrayList<>(Arrays.asList(array))

3962
2017-10-01 14:39



Dado:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

La respuesta más simple es hacer:

List<Element> list = Arrays.asList(array);

Esto funcionará bien. Pero algunas advertencias:

  1. La lista devuelta por asList tiene tamaño fijo. Por lo tanto, si desea poder agregar o quitar elementos de la lista devuelta en su código, deberá envolverlo en un nuevo ArrayList. De lo contrario, obtendrás un UnsupportedOperationException.
  2. La lista regresada de asList() está respaldado por la matriz original. Si modifica la matriz original, la lista también se modificará. Esto puede ser sorprendente.

774
2017-10-01 15:39



(hilo viejo, pero solo 2 centavos ya que ninguno menciona Guava u otras libs y algunos otros detalles)

Si puedes, usa guayaba

Vale la pena señalar la forma de Guava, que simplifica enormemente estas travesuras:

Uso

Para una lista inmutable

Utilizar el ImmutableList clase y su of() y copyOf() métodos de fábrica (los elementos no pueden ser nulos):

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Para una lista mutable

Utilizar el Lists clase y su newArrayList() métodos de fábrica:

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Tenga en cuenta también los métodos similares para otras estructuras de datos en otras clases, por ejemplo en Sets.

¿Por qué guayaba?

La principal atracción podría ser reducir el desorden debido a los genéricos para la seguridad de tipo, como el uso de la guayaba. métodos de fábrica permite que los tipos se infieran la mayor parte del tiempo. Sin embargo, este argumento contiene menos agua desde que Java 7 llegó con el nuevo operador de diamantes.

Pero no es la única razón (y Java 7 aún no está en todas partes): la sintaxis abreviada también es muy útil, y los iniciadores de métodos, como se ve arriba, permiten escribir un código más expresivo. Lo haces en una llamada de guayaba lo que lleva 2 con las colecciones de Java actuales.


Si no puedes ...

Para una lista inmutable

Usa el JDK Arrays clase y su asList() método de fábrica, envuelto con un Collections.unmodifiableList():

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Tenga en cuenta que el tipo devuelto para asList() es un List usando un concreto ArrayList implementación, pero no lo es  java.util.ArrayList. Es un tipo interno, que emula un ArrayList pero en realidad hace referencia directamente a la matriz pasada y la hace "escribir a través de" (las modificaciones se reflejan en la matriz).

Prohíbe las modificaciones a través de algunos de los List Métodos de API simplemente extendiendo un AbstractList (por lo tanto, agregar o quitar elementos no es compatible), sin embargo, permite llamadas a set() para anular elementos. Por lo tanto, esta lista no es realmente inmutable y una llamada a asList() debe ser envuelto con Collections.unmodifiableList().

Vea el próximo paso si necesita una lista mutable.

Para una lista mutable

Lo mismo que arriba, pero envuelto con un real java.util.ArrayList:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

Con fines educativos: The Good ol 'Manual Way

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}

295
2017-11-16 17:16



Como esta pregunta es bastante antigua, me sorprende que nadie haya sugerido la forma más simple hasta ahora:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

A partir de Java 5, Arrays.asList() toma un parámetro varargs y no tiene que construir el conjunto de forma explícita.


203
2018-06-22 11:30



new ArrayList<T>(Arrays.asList(myArray));

Asegúrate de eso myArray es del mismo tipo que T. Obtendrá un error de compilación si intenta crear un List<Integer>de una serie de int, por ejemplo.


172
2017-10-01 14:40



Otra forma (aunque esencialmente equivalente a la new ArrayList(Arrays.asList(array)) solución en cuanto al rendimiento:

Collections.addAll(arraylist, array);

77
2018-04-03 23:20



Probablemente solo necesites una Lista, no una Lista de Arreglos. En ese caso, puedes hacer:

List<Element> arraylist = Arrays.asList(array);

62
2017-10-01 14:45



Java 9

En Java 9, puedes usar List.of método de fábrica estático para crear un List literal. Algo como lo siguiente:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Esto devolvería un inmutable lista que contiene tres elementos. Si quieres un mudable lista, pasa esa lista al ArrayList constructor:

new ArrayList<>(List.of(// elements vararg))

JEP 269: métodos de fábrica de conveniencia para colecciones

JEP 269 proporciona algunos métodos de fábrica de conveniencia para Colecciones de Java API. Estos métodos de fábrica estáticos inmutables están integrados en List, Sety Map interfaces en Java 9 y posterior.


59
2018-04-17 16:58