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 arraylist = ???; 

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

Dado:

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

La respuesta más simple es hacer:

 List list = Arrays.asList(array); 

Esto funcionará bien. Pero algunas advertencias:

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

(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

Use la clase copyOf() y copyOf() métodos de fábrica of() y copyOf() (los elementos no pueden ser nulos) :

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

Para una lista mutable

Use la clase Lists y sus newArrayList() métodos de fábrica newArrayList() :

 List l1 = Lists.newArrayList(anotherListOrCollection); // from collection List l2 = Lists.newArrayList(aStringArray); // from array List 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 generics para la seguridad del tipo, ya que el uso de los métodos de la fábrica de guayaba 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 syntax 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

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

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

Tenga en cuenta que el tipo devuelto para asList() es una List utiliza una implementación ArrayList concreta, pero NO es java.util.ArrayList . Es un tipo interno, que emula una 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 métodos de API de List simplemente extendiendo una lista AbstractList (por lo tanto, agregar o quitar elementos no es compatible), sin embargo, permite que las llamadas a set() anulen los elementos. Por lo tanto, esta lista no es realmente inmutable y una llamada a asList() debe incluirse en Collections.unmodifiableList() .

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

Para una lista mutable

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

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

Con fines educativos: The Good ol ‘Manual Way

 // for Java 1.5+ static  List arrayToList(final T[] array) { final List l = new ArrayList(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 la forma más simple hasta ahora:

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

 new ArrayList(Arrays.asList(myArray)); 

Asegúrese de que myArray sea ​​del mismo tipo que T Obtendrá un error de comstackción si intenta crear una List partir de una matriz de int , por ejemplo.

Otra forma (aunque esencialmente equivalente a la new ArrayList(Arrays.asList(array)) rendimiento:

 Collections.addAll(arraylist, array); 

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

 List arraylist = Arrays.asList(array); 

Java 9

En Java 9 , puede usar la List.of métodos de fábrica estáticos para crear un literal de List . Algo como lo siguiente:

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

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

 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 Java Collections API. Estos métodos de fábrica estáticos inmutables están integrados en las interfaces List , Set y Map en Java 9 y posterior.

Otra actualización, que casi termina el año 2014, también puedes hacerlo con Java 8:

 ArrayList arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new)); 

Se guardarían unos pocos caracteres, si esto solo fuera una List

 List list = Stream.of(myArray).collect(Collectors.toList()); 

Para convertir una matriz a una ArrayList, los desarrolladores a menudo hacen esto:

 List list = Arrays.asList(arr);// this is wrong way.. 

Arrays.asList() devolverá una ArrayList que es una private static class inside Arrays , no es la clase java.util.ArrayList. The java.util.Arrays.ArrayList clase The java.util.Arrays.ArrayList tiene métodos set(), get(), contains() , pero no tiene ningún método para agregar elementos, por lo que su tamaño es fijo. Para crear una ArrayList real, debe hacer:

 ArrayList arrayList = new ArrayList(Arrays.asList(arr)); 

El constructor de ArrayList puede aceptar un tipo de colección , que también es un tipo super para java.util.Arrays.ArrayList

Si utiliza :

 new ArrayList(Arrays.asList(myArray)); 

¡ puedes crear y llenar dos listas! Llenar dos veces una gran lista es exactamente lo que no desea hacer, ya que creará otra matriz Object[] cada vez que la capacidad necesite extenderse.

Afortunadamente, la implementación de JDK es rápida y Arrays.asList(a[]) está muy bien hecha. Crea un tipo de ArrayList llamado Arrays.ArrayList donde los datos de Object [] apuntan directamente a la matriz.

 // in Arrays @SafeVarargs public static  List asList(T... a) { return new ArrayList<>(a); } //still in Arrays, creating a private unseen class private static class ArrayList private final E[] a; ArrayList(E[] array) { a = array; // you point to the previous array } .... } 

El lado peligroso es que si cambias la matriz inicial, ¡cambias la Lista! ¿Estás seguro de que quieres eso? Tal vez si tal vez no.

Si no, la forma más comprensible es hacer esto:

 ArrayList list = new ArrayList(myArray.length); // you know the initial capacity for (Element element : myArray) { list.add(element); } 

O como dijo @glglgl, puede crear otra ArrayList independiente con:

 new ArrayList(Arrays.asList(myArray)); 

Me encanta usar Collections , Arrays o Guava. Pero si no le queda, o no lo siente, simplemente escriba otra línea poco elegante en su lugar.

En Java 9 puedes usar:

 List list = List.of("Hello", "World", "from", "Java"); List list = List.of(1, 2, 3, 4, 5); 

De acuerdo con la pregunta, la respuesta usando java 1.7 es:

 ArrayList arraylist = new ArrayList(Arrays.asList(array)); 

Sin embargo, es mejor siempre usar la interfaz:

 List arraylist = Arrays.asList(array); 
 // Guava import com.google.common.collect.ListsLists ... List list = Lists.newArrayList(aStringArray); 

Puedes convertir usando diferentes métodos

  1. List list = Arrays.asList(array);

  2. List list = new ArrayList();
    Collections.addAll(list, array);

  3. Arraylist list = new Arraylist();
    list.addAll(Arrays.asList(array));

Para obtener más detalles, puede consultar http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

También puede hacerlo con stream en Java 8.

  List elements = Arrays.stream(array).collect(Collectors.toList()); 

Desde Java 8 hay una manera más fácil de transformar:

 public static  List fromArray(T[] array) { return Arrays.stream(array).collect(toList()); } 
  1. Si vemos la definición del método Arrays.asList() obtendrá algo como esto:

      public static  List asList(T... a) //varargs are of T type. 

    Entonces, podrías inicializar una lista de arraylist como esta:

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

    Nota : cada new Element(int args) se tratará como Objeto individual y se puede pasar como var-args .

  2. Puede haber otra respuesta para esta pregunta también.
    Si ve la statement del método java.util.Collections.addAll() , obtendrá algo como esto:

     public static  boolean addAll(Collection c, T... a); 

    Entonces, este código también es útil para hacerlo

     Collections.addAll(arraylist, array); 

Otra forma simple es agregar todos los elementos de la matriz a una nueva ArrayList usando un ciclo for-each.

 ArrayList list = new ArrayList<>(); for(Element e : array) list.add(e); 

como todos dijeron, esto lo hará

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

y la forma más nueva y común de crear una matriz es observableArrays

ObservableList: una lista que permite a los oyentes rastrear los cambios cuando ocurren.

para Java SE puedes probar

 FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3)); 

eso es según Oracle Docs

observableArrayList () Crea una nueva lista observable vacía respaldada por una lista de arrays. observableArrayList (E … elementos) Crea una nueva lista de matriz observable con elementos agregados.

Actualiza Java 9

también en Java 9 es un poco fácil:

 List list = List.of("element 1", "element 2", "element 3"); 

Dado:

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

Utilizar:

 List listArray = Arrays.asList(array); 

Si la matriz es de tipo primitivo, las respuestas dadas no funcionarán. Pero desde Java 8 puedes usar:

 int[] array = new int[5]; Arrays.stream(array).boxed().collect(Collectors.toList()); 

Aunque hay muchas respuestas perfectamente escritas para esta pregunta, agregaré mis entradas.

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

Nueva ArrayList se puede crear de las siguientes maneras

 ArrayList arraylist_1 = new ArrayList<>(Arrays.asList(array)); ArrayList arraylist_2 = new ArrayList<>( Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) })); // Add through a collection ArrayList arraylist_3 = new ArrayList<>(); Collections.addAll(arraylist_3, array); 

Y soportan muy bien todas las operaciones de ArrayList

 arraylist_1.add(new Element(4)); // or remove(): Success arraylist_2.add(new Element(4)); // or remove(): Success arraylist_3.add(new Element(4)); // or remove(): Success 

Pero las siguientes operaciones devuelven solo una vista de lista de una ArrayList y no una ArrayList real.

 // Returns a List view of array and not actual ArrayList List listView_1 = (List) Arrays.asList(array); List listView_2 = Arrays.asList(array); List listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3)); 

Por lo tanto, darán error cuando intenten realizar algunas operaciones de ArrayList

 listView_1.add(new Element(4)); // Error listView_2.add(new Element(4)); // Error listView_3.add(new Element(4)); // Error 

Más sobre la representación de la lista del enlace de la matriz.

La forma más simple de hacerlo es agregar el siguiente código. Tratado y probado.

 String[] Array1={"one","two","three"}; ArrayList s1= new ArrayList(Arrays.asList(Array1)); 

Podemos convertir fácilmente una matriz a ArrayList . Utilizamos el método addAll() la interfaz de Colección para copiar contenido de una lista a otra.

  Arraylist arr = new Arraylist(); arr.addAll(Arrays.asList(asset)); 

Otra solución Java8 (puede haber perdido la respuesta entre el conjunto grande. Si es así, mis disculpas). Esto crea una ArrayList (a diferencia de una Lista) es decir, uno puede eliminar elementos

 package package org.something.util; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Junk { static  ArrayList arrToArrayList(T[] arr){ return Arrays.asList(arr) .stream() .collect(Collectors.toCollection(ArrayList::new)); } public static void main(String[] args) { String[] sArr = new String[]{"Hello", "cruel", "world"}; List ret = arrToArrayList(sArr); // Verify one can remove an item and print list to verify so ret.remove(1); ret.stream() .forEach(System.out::println); } } 

La salida es …
Hola
mundo

Ya todos han proporcionado suficiente buena respuesta para su problema. Ahora, de todas las sugerencias, debe decidir cuál se ajustará a sus necesidades. Hay dos tipos de colección que necesita saber. Una es colección no modificada y otra colección que le permitirá modificar el objeto más adelante.

Entonces, aquí daré un breve ejemplo para dos casos de uso.

  • Creación de colección inmutable :: Cuando no desea modificar el objeto de colección después de la creación

    List elementList = Arrays.asList(array)

  • Creación de colecciones mutables: cuando desee modificar el objeto de colección creado después de la creación.

    List elementList = new ArrayList(Arrays.asList(array));

Puedes hacerlo en java 8 de la siguiente manera

 ArrayList list = (ArrayList)Arrays.stream(array).collect(Collectors.toList()); 
  Element[] array = {new Element(1), new Element(2), new Element(3)}; List elements=Arrays.asList(array); 

Puede crear una ArrayList usando Cactoos (soy uno de los desarrolladores):

 List names = new StickyList<>( "Scott Fitzgerald", "Fyodor Dostoyevsky" ); 

No hay garantía de que el objeto sea realmente de clase ArrayList . Si necesita esa garantía, haga esto:

 ArrayList list = new ArrayList<>( new StickyList<>( "Scott Fitzgerald", "Fyodor Dostoyevsky" ) );