Având în vedere:

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

Răspunsul cel mai simplu este sa faci:

List list = Arrays.asList(array);

Aceasta va funcționa bine. Dar unele limitări:

1. Lista întors din asList a dimensiune fixă. Deci, dacă doriți să fie în măsură pentru a adăuga sau elimina elemente din lista returnată în codul dvs.,'ll nevoie pentru a încheia într-o nou ArrayList. Altfel'll o UnsupportedOperationException.
2. Lista întors de la asList() este susținută de matrice inițială. Dacă modificați matrice inițială, lista va fi modificat la fel de bine. Acest lucru poate fi surprinzător.

(thread vechi, dar doar 2 cenți ca nici unul nu mai vorbim de Guava sau alte libs și alte detalii)

Dacă Aveți Posibilitatea, Folosiți Guava

L's valoare de subliniind Guava fel, care simplifică foarte mult aceste comice:

Utilizare

Pentru o Lista Imuabil

Folosi ImmutableList clasă și a() și copyOf() fabrica de metode (elemente pot't fi null):

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

Pentru O Mutabil Lista

Folosi Liste clasă și newArrayList() fabrica de metode:

List l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List l2 = Lists.newArrayList(aStringArray);               // from array
List l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Vă rugăm să rețineți, de asemenea, metode similare pentru alte structuri de date în alte clase, de exemplu în Seturi.

De Ce Guava?

Principalul punct de atractie ar putea fi pentru a reduce dezordinea din cauza generice de tip siguranță, ca utilizarea de Guava fabrica de metode permite ca tipurile să fie dedusă cele mai multe ori. Cu toate acestea, acest argument deține mai puțin de apă din Java 7 a sosit cu noul diamant operator.

Dar's nu este singurul motiv (și Java 7 e't peste tot încă): scurtătura sintaxa este, de asemenea, foarte la îndemână, și metode de initializare, cum am văzut mai sus, permite să se scrie mai mult cod expresiv. Ai face într-o singură Guava apel ce durează 2 cu actualele Colecții Java.

Dacă Ai Poate't...

Pentru o Lista Imuabil

Utilizarea JDK's Tablouri clasă și asList() metoda fabrica, înfășurat cu un Colecții.unmodifiableList():

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

Rețineți că s-a întors tipul de asList()e o "Listă" cu ajutorul unui betonArrayList în aplicare, dar NU java.util.ArrayList. L's un interior de tip, care emulează un ArrayList` dar de fapt direct referințe la trecut matrice și o face "scrie" (modificările sunt reflectate în matrice).

Se interzice modificări prin unele din "Lista" API's metode prin simpla extindere o AbstractList (deci, adăugarea sau eliminarea de elemente este de neacceptat), cu toate acestea, se permite apeluri să set() pentru a înlocui elementele. Astfel, această listă nu este't cu adevărat imuabil și un apel la asList() ar trebui să fie înfășurat cu Colectiile.unmodifiableList()`.

Vezi următorul pas dacă aveți nevoie de un mutabil lista.

Pentru o Mutabil Lista

La fel ca mai sus, dar înfășurat cu o real java.util.ArrayList:

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+

Pentru Scopuri Educaționale: Bun ol' Mod Manual

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

Deoarece această întrebare este destul de vechi, mă surprinde că nimeni nu a sugerat cea mai simplă formă încă:

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

Ca de Java 5, Matrice.asList() ia o varargs parametru și nu't au de a construi matrice în mod explicit.

new ArrayList(Arrays.asList(myArray));

Asigurați-vă că myArray este de același tip ca și "T". Te'll obține un compiler eroare dacă încercați să creați o Listădintr-o serie deint`, de exemplu.

Un alt mod (deși, în esență echivalent cu new ArrayList(Tablouri.asList(array)) soluție performance-wise:

Collections.addAll(arraylist, array);

Java 9

În Java 9, puteți utiliza Lista.a metoda statica fabrică în scopul de a crea o "Listă" de literal. Ceva de genul următor:

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

Acest lucru ar reveni un imuabil listă care conține trei elemente. Dacă doriți un mutabil lista, trece această listă ArrayList constructor:

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

JEP 269: Confort Fabrica de Metode pentru Colecții

JEP 269 oferă un confort fabrica de metode pentru Colecții Java API. Aceste imuabil metode fabrică statice sunt construite în Lista, Stabilit, și Harta interfețe în Java 9 și mai târziu.

Probabil ai nevoie doar de o Lista, nu un ArrayList. În acest caz puteți face:

List arraylist = Arrays.asList(array);

Un alt update, aproape de finalul anului 2014, o poti face cu Java 8:

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

Câteva personaje-ar fi salvat, dacă acest lucru ar putea fi doar o "Listă"

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

Dacă utilizați :

new ArrayList(Arrays.asList(myArray));

ai poate crea și umple două liste ! Umplere de două ori o listă mare este exact ceea ce ai nu't vreau să fac pentru că se va crea un alt Obiect[]` matrice de fiecare dată de capacitatea trebuie să fie extinsă.

Din fericire JDK aplicare este rapid și Tablouri.asList(a[])` este foarte bine făcut. Se crea un fel de ArrayList numit Matrice.ArrayList unde Object[] puncte de date direct de la matrice.

// 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
    }
    ....
}

Partea periculoasă e care dacă schimbați inițială matrice, puteți modifica Lista ! Ești sigur că vrei asta ? Poate da, poate nu.

Dacă nu, cel mai ușor de înțeles este de a face acest lucru :

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

Sau cum a spus @glglgl, puteți crea un alt independent ArrayList cu :

new ArrayList(Arrays.asList(myArray));

Îmi place să folosesc "Colecții", Matrice, sau Guava. Dar dacă don't se potrivesc, sau tu nu't simt, doar scrie un alt neelegant linie în loc.

În Java 9` poti folosi:

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

În conformitate cu întrebarea răspunsul folosind java 1.7 este:

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

Cu toate acestea, de's întotdeauna mai bine de a folosi interfata:

List arraylist = Arrays.asList(array);

Puteți converti folosind diferite metode

1. Lista list = Matrice.asList(matrice);`

2. Lista list = new ArrayList(); Colecții.addAll(lista, matrice);`

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

Pentru mai multe detalii puteți consulta http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

ca tot spus acest lucru o va face

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

și comune mai nou mod de a crea matrice este observableArrays

ObservableList: O listă care vă permite ascultătorilor să urmăriți modificările atunci când acestea apar.

pentru Java SE, puteți încerca

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

care este potrivit Oracle Docs

observableArrayList() Creează un nou gol observabil lista, care este susținută de un arraylist. observableArrayList(E... de articole) Creează un nou observabile listă matrice cu elemente adăugate la acesta.

Update Java 9

de asemenea, în Java 9 l's un pic mai ușor:

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

Deoarece Java 8 există o cale mai ușoară de a transforma:

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

De asemenea, puteți face cu flux în Java 8.

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

1. Dacă vom vedea definiția de Tablouri.asList()` metoda veți obține ceva de genul asta:

public static Listă asList(T o) //varargs sunt de tip T.

Deci, s-ar putea inițializa arraylist astfel:

Listă arraylist = Matrice.asList(nou Element(1),Element nou(2),nou Element(3));

Notă : fiecare nou Element(int args)va fi tratat ca un Obiect Individual și poate fi trecut ca unvar-args`.

2. Ar putea fi un răspuns pentru această întrebare. Dacă vedeți declarația pentru java.util.Colecții.addAll()` metoda veți obține ceva de genul asta:

public static boolean addAll(Collection<? super T> c, T... a); Deci, acest cod este, de asemenea, util să se facă astfel încât

Colecții.addAll(arraylist, matrice);

Un alt mod simplu este de a adăuga toate elementele din matrice la un nou ArrayList folosind-o pentru fiecare buclă.

ArrayList list = new ArrayList();

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

Dacă o matrice este de un tip primitiv, dat răspunsuri câștigat't de lucru. Dar din moment Java 8, puteți folosi:

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