Crear ArrayList a partir de una matriz
Element[] array = {new Element(1), new Element(2), new Element(3)};
¿ Cómo convierto la variable de tipo anterior Element[]en una variable de tipo ArrayList<Element>?
ArrayList<Element> arrayList = ...;
Puede utilizar las siguientes instrucciones:
new ArrayList<>(Arrays.asList(array));
Dado:
Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };
La respuesta más sencilla es hacer:
List<Element> list = Arrays.asList(array);
Esto funcionará bien. Pero algunas advertencias:
- La lista devuelta por asList tiene un tamaño fijo . Por lo tanto, si desea poder agregar o eliminar elementos de la lista devuelta en su código, deberá envolverlo en un nuevo archivo
ArrayList. De lo contrario obtendrás unUnsupportedOperationException. - La lista devuelta
asList()está respaldada por la matriz original. Si modifica la matriz original, la lista también se modificará. Esto puede resultar sorprendente.
(hilo antiguo, pero solo 2 centavos ya que ninguno menciona Guava u otras bibliotecas y algunos otros detalles)
Si puedes, usa guayaba
Vale la pena señalar el método Guava, que simplifica enormemente estas travesuras:
Uso
Para una lista inmutable
Utilice la ImmutableListclase y sus of()métodos copyOf()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
Utilice la Listsclase y sus 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?
El principal atractivo podría ser reducir el desorden debido a los genéricos para la seguridad de tipos, ya que el uso de los métodos de la fábrica Guava permite inferir los tipos la mayor parte del tiempo. Sin embargo, este argumento tiene menos fundamento desde que llegó Java 7 con el nuevo operador de diamante.
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 inicializadores de métodos, como se vio arriba, permiten escribir código más expresivo. Lo haces en una llamada de Guava lo que se necesitan 2 con las colecciones de Java actuales.
Si no puedes...
Para una lista inmutable
Utilice la clase del JDK Arraysy 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 asList()utiliza Listuna implementación concreta ArrayList, pero NO lo es java.util.ArrayList . Es un tipo interno, que emula ArrayListpero en realidad hace referencia directa a la matriz pasada y la hace "escritura" (las modificaciones se reflejan en la matriz).
Prohíbe modificaciones a través de algunos de los Listmétodos de la API simplemente extendiendo un AbstractList(por lo tanto, no se admite agregar o eliminar elementos), sin embargo, permite llamadas para set()anular elementos. Por lo tanto, esta lista no es realmente inmutable y una llamada a asList()debe ir acompañada de Collections.unmodifiableList().
Consulte el siguiente paso si necesita una lista mutable.
Para una lista mutable
Igual que el anterior, 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+
Para fines educativos: el buen método manual
// 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);
}
Como esta pregunta es bastante antigua, me sorprende que nadie haya sugerido todavía la forma más simple:
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 es necesario construir la matriz explícitamente.
new ArrayList<T>(Arrays.asList(myArray));
Asegúrate de que myArraysea del mismo tipo que T. Obtendrá un error del compilador si intenta crear a List<Integer>partir de una matriz de int, por ejemplo.
