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 que se devuelve de asList tiene tamaño fijo. Por lo tanto, si usted quiere ser capaz de agregar o quitar elementos de la lista devuelta en el código, tendrás que envolver en una nueva ArrayList. De lo contrario, obtendrá un UnsupportedOperationException.
2. La lista que se devuelve desde asList() está respaldado por la matriz original. Si modifica la matriz original, la lista se modifica. Esto puede ser sorprendente.

^{(pasado de rosca, pero sólo 2 centavos de dólar como ninguna mención de Guayaba o de otras librerías y algunos otros detalles)}

Si Puede, Utilice La Guayaba

Vale la pena señalar la Guayaba manera, lo que simplifica enormemente estas travesuras:

Uso

Para una Lista Inmutable

El uso de la ImmutableList de la clase y su of() y copyOf() métodos de fábrica ^{(elementos no puede ser null)}:

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

Para Mutables Lista

El uso de la Lists de la 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

Por favor, también tenga en cuenta la similitud de los métodos para otras estructuras de datos en otras clases, por ejemplo en Sets.

¿Por Qué La Guayaba?

La principal atracción podría ser reducir el desorden debido a los medicamentos genéricos para el tipo de seguridad, como el uso de la Guayaba métodos de fábrica permitir que los tipos se deduce que la mayoría del tiempo. Sin embargo, este argumento tiene menos agua, ya que Java 7 llegó con el nuevo diamante de operador.

Pero no es la única razón (y Java 7 no es en todas partes): la sintaxis abreviada también es muy útil, y los métodos de inicializadores, como se ha visto anteriormente, permiten escribir más expresivo de código. Que hacer en una Guayaba llamar a lo que tarda 2 con la actualidad de Colecciones Java.

Si Usted no Puede...

Para una Lista Inmutable

Utilizar el JDK de la Arrays de la clase y su asList() método de fábrica, que se envuelve 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 por asList() es List el uso de un hormigón ArrayList de ejecución, pero NO es java.util.ArrayList. Es un tipo interno, que emula a un ArrayList pero en realidad hace referencia directamente al pasado de la matriz y lo hace "escribir a través de" (las modificaciones se reflejan en la matriz).

Se prohíbe las modificaciones a través de algunos de los List de la API de los métodos por medio de la simple extensión de un AbstractList (por lo tanto, la adición o eliminación de elementos no es compatible), sin embargo, se permite que las llamadas a set() reemplazar elementos. Así, esta lista no es verdaderamente inmutable y una llamada a asList() deben ser envueltos con Collections.unmodifiableList().

Ver el siguiente paso si usted necesita un mutable de la lista.

Para Mutables Lista

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+

Con Fines Educativos: El Buen ol' Forma 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);
}

Esta cuestión ya es bastante viejo, es sorprendente que nadie me sugirió la forma más simple aún:

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

Como de Java 5, Arrays.asList() toma un varargs parámetro y usted no tiene que construir la matriz explícito.

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