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:

1. La lista devuelta por asList tiene tamaño fijo. Por lo tanto, si desea poder agregar o eliminar elementos de la lista devuelta en su código, deberá ajustarlo en un nuevo ArrayList. De lo contrario, obtendrás un UnsupportedOperationException.
2. La lista devuelta de asList() está respaldado 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 puede, use guayaba

Vale la pena señalar el método Guava, que simplifica enormemente estas travesuras:

Uso

Para una lista inmutable

Use 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

Use 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?

El principal atractivo 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 Permitir que los tipos se infieran la mayor parte del tiempo. Sin embargo, este argumento tiene menos fundamento desde que llegó Java 7 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 inicializadores de métodos, como se vio arriba, permiten escribir código más expresivo. Lo haces en una llamada de Guava lo que toma 2 con las colecciones de Java actuales.

Si no puedes ...

Para una lista inmutable

Usa los 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" (las modificaciones se reflejan en la matriz).

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

Vea el siguiente paso si necesita una lista mutable.

Para una lista mutable

Igual 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: 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);
}

Dado que esta pregunta es bastante antigua, me sorprende que nadie sugiera 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 la matriz explícitamente.

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

Asegurar que myArray es del mismo tipo que T. Obtendrá un error del compilador si intenta crear un List<Integer> de una matriz de int, por ejemplo.

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

Collections.addAll(arraylist, array);

Java 9

In Java 9, puedes usar List.of método de fábrica estática para crear un List literal. Algo parecido a 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, pase esa lista a la 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 inmutables de fábrica estática están integrados en el List, Set y Map interfaces en Java 9 y posteriores.

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

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

Otra actualización, casi terminando el año 2014, también puedes 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 utiliza :

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

te lleve puede Para crear y llenar dos listas! Llenar dos veces una lista grande es exactamente lo que no desea hacer porque creará otra Object[] matriz cada vez que se necesite ampliar la capacidad.

Afortunadamente, la implementación de JDK es rápida y Arrays.asList(a[]) está muy bien hecho. Crea una especie de ArrayList llamada Arrays.ArrayList donde los datos de Object [] 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ás seguro de que quieres eso? Tal vez si tal vez no.

Si no es así, 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:

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

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

In Java 9 puedes 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 usando 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

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

import java.util.List;    
import static java.util.stream.Collectors.toList;

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

como todos dijeron, esto lo hará

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

y la forma más común de crear una matriz es matrices observables

Lista observable: Una lista que permite a los oyentes realizar un seguimiento de los cambios cuando ocurren.

para Java SE puedes probar

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

eso es de acuerdo con Documentos de Oracle

observableArrayList () Crea una nueva lista observable vacía respaldada por una lista de matrices. observableArrayList (E ... items) Crea una nueva lista de matrices observables 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 puede hacerlo con stream en Java 8.

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

1. Si vemos la definición de Arrays.asList() método obtendrá algo como esto:

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

   Entonces, podrías inicializar arraylist Me gusta esto:

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

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

2. También podría haber otra respuesta para esta pregunta.
   Si ve una declaración para java.util.Collections.addAll() método 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 sencilla es agregar todos los elementos de la matriz a una nueva ArrayList usando un bucle for-each.

ArrayList<Element> list = new ArrayList<>();

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

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

Puedes hacerlo en java 8 de la siguiente manera

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

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

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

La nueva ArrayList se puede crear 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 son muy compatibles con 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 tanto, darán error al intentar realizar algunas operaciones 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 lista de matriz aquí.

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

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

Otra solución Java8 (Es posible que me haya perdido la respuesta entre el grupo 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 <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

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

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

Utilice 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]);
}

Matriz de objetos dada:

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

Convertir matriz en lista:

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

Convertir Array en ArrayList

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

Convertir matriz en LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

Lista de impresión:

    list.forEach(element -> {
        System.out.println(element.i);
    });

SALIDA

1

2

3

Ya todo el mundo ha dado una buena respuesta a su problema. Ahora, a partir de todas las sugerencias, debe decidir cuál se ajustará a sus necesidades. Hay dos tipos de recopilación que debe conocer. Una es la colección sin modificar y la otra colección que le permitirá modificar el objeto más tarde.

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

La clase Arrays de Java 8 proporciona un método stream () que tiene versiones sobrecargadas que aceptan tanto matrices primitivas como matrices de objetos.

/**** Converting a Primitive 'int' Array to List ****/

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

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());

El siguiente código parece una buena forma de hacer esto.

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