Pregunta

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 = ???;
¿Fue útil?

Solución

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

Otros consejos

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 desde asList tiene 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 ArrayList. De lo contrario, obtendrá un UnsupportedOperationException.
  2. La lista devuelta desde asList() está respaldada por la matriz original. Si modifica la matriz original, la lista también se modificará. Esto puede ser sorprendente.

(hilo antiguo, pero solo 2 centavos, ya que ninguno menciona la guayaba u otras libs y algunos otros detalles)

Si puedes, usa guayaba

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

Uso

Para una lista inmutable

Utilice el <= > clase y su ImmutableList y of() 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

Utilice el <= > clase y su copyOf() 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 Lists .

¿Por qué Guava?

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

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


Si no puedes ...

Para una lista inmutable

Utilice el newArrayList() del JDK clase y su < => método de fábrica, envuelto con una Sets :

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 Arrays es un asList() que utiliza una implementación concreta Collections.unmodifiableList(), pero NO lo es List. Es un tipo interno, que emula un ArrayList pero en realidad hace referencia directa a la matriz pasada y lo hace & "; Escriba a través de &"; (las modificaciones se reflejan en la matriz).

Prohíbe modificaciones a través de algunos de los métodos de API de java.util.ArrayList 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 <=> debe incluirse con <=>.

Vea el siguiente paso si necesita una lista mutable.

Para una lista mutable

Igual que el anterior, pero envuelto con un <=>:

real
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: la buena manera 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 la forma más simple todavía:

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 la matriz explícitamente.

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

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

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

Collections.addAll(arraylist, array);

Java 9

En Java 9 , puede usar List.of método de fábrica estático para crear un <= > literal. Algo así como lo siguiente:

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

Esto devolvería un immutable lista que contiene tres elementos. Si desea una lista mutable , pase esa lista al constructor List:

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

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

JEP 269 proporciona algunos métodos de fábrica convenientes para API de colecciones Java . Estos métodos de fábrica estáticos inmutables están integrados en ArrayList , Set , y Map interfaces en Java 9 y posterior .

Probablemente solo necesite una Lista, no una ArrayList. En ese caso, solo puede hacer:

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

Otra actualización, casi terminando el año 2014, también puede hacerlo con Java 8:

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

Se guardarían algunos caracteres, si esto pudiera ser solo un List

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

Si usa:

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

usted puede crear y llenar dos listas! Llenar dos veces una lista grande es exactamente lo que no desea hacer, ya que creará otra Object[] matriz cada vez que deba ampliarse la capacidad.

Afortunadamente, la implementación de JDK es rápida y Arrays.asList(a[]) está muy bien hecha. Crea una especie de ArrayList llamada Arrays.ArrayList donde los datos del Objeto [] apuntan directamente a la matriz.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

¡El lado peligroso es que si cambia la matriz inicial, cambia la Lista! ¿Está seguro de querer eso? Quizás sí, quizás no.

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

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

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

<*>

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

En Java 9 puede usar:

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

De acuerdo con la pregunta, la respuesta con Java 1.7 es:

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

Sin embargo, es mejor usar siempre la interfaz:

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

Puedes convertir usando diferentes métodos

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

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

como todos dijeron, esto lo hará

 new ArrayList<>(Arrays.asList("1","2","3","4"));

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

de acuerdo con Oracle Docs

  

observableArrayList ()   Crea una nueva lista observable vacía que está respaldada por una lista de matrices.   observableArrayList (E ... artículos)   Crea una nueva lista de matriz observable con elementos agregados.

Actualizar Java 9

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

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

También puedes hacerlo con stream en Java 8.

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

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

public static <T> List<T> 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 <T> List<T> asList(T... a) //varargs are of T type. 
    

    Entonces, puede inicializar arraylist de esta manera:

     List<Element> 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 un var-args.

  2. Puede haber otra respuesta para esta pregunta también.
    Si ve una declaración para el método java.util.Collections.addAll() obtendrá algo como esto:

    public static <T> boolean addAll(Collection<? super T> 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<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);

Si la matriz es de un 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());

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

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

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

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

Se puede crear una nueva ArrayList de las siguientes maneras

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> 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<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

Por lo tanto, darán error al intentar 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 información sobre la representación de la lista de link . / p>

La forma más sencilla de hacerlo es agregando el siguiente código. Probado y probado.

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

Otra solución Java8 (es posible que haya perdido la respuesta entre el conjunto grande. Si es así, mis disculpas). Esto crea una ArrayList (en lugar 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 <T> ArrayList<T>  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<String> 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

Puedes hacerlo en Java 8 de la siguiente manera

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

Ya todos han proporcionado suficiente respuesta buena para su problema. Ahora, a partir de todas las sugerencias, debe decidir cuál se adaptará a sus necesidades. Hay dos tipos de colección que necesita saber. Una es una 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<Element> elementList = Arrays.asList(array)

  • Creación de colección mutable :: Cuando desee modificar el objeto de colección creado después de la creación.

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

Use el siguiente código para convertir una matriz de elementos en una ArrayList.

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

ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}

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

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

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

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

Usar el siguiente código

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> list = (ArrayList) Arrays.asList(array);

Esta es una forma clara de eso

ArrayList<Element> arraylist = new ArrayList<>(Arrays.asList(array))
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top