Erstellen Sie ArrayList aus Array

Gegeben:

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

Die einfachste Antwort lautet:

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

Das wird gut funktionieren. Aber einige Vorbehalte:

1. Die von asList zurückgegebene Liste hat feste Größe . Wenn Sie also Elemente zur zurückgegebenen Liste in Ihrem Code hinzufügen oder daraus entfernen möchten, müssen Sie sie in eine neue ArrayList einschließen. Andernfalls erhalten Sie eine UnsupportedOperationException.
2. Die von asList() zurückgegebene Liste wird durch das ursprüngliche Array gesichert. Wenn Sie das ursprüngliche Array ändern, wird auch die Liste geändert. Das kann überraschend sein. 

^{(alter Thread, aber nur 2 Cent, da keiner Guava oder andere Libs und einige andere Details erwähnt)}

Wenn Sie können, verwenden Sie Guave

Es lohnt sich, auf den Guaven-Weg hinzuweisen, der diese Phänomene erheblich vereinfacht:

Verwendungszweck

Für eine unveränderliche Liste

Verwenden Sie die Methoden ImmutableList und ihre of() - und copyOf() factory-Methoden ^{(Elemente dürfen nicht null sein)}:

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

Für eine veränderliche Liste

Verwenden Sie die Lists class und ihre newArrayList() factory-Methoden:

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

Beachten Sie auch die ähnlichen Methoden für andere Datenstrukturen in anderen Klassen, beispielsweise in Sets .

Warum Guave?

Die Hauptattraktion könnte darin bestehen, die Unordnung aufgrund von Generika für die Typsicherheit zu reduzieren, da die Verwendung der Guava Factory-Methoden die meist abgelesenen Typen zulässt. Dieses Argument hält jedoch weniger Wasser, seit Java 7 mit dem neuen Diamantenoperator eingetroffen ist.

Dies ist jedoch nicht der einzige Grund (und Java 7 ist noch nicht überall): Die Abkürzungssyntax ist auch sehr praktisch, und die Methodeninitialisierer (siehe oben) ermöglichen das Schreiben von ausdrucksvollerem Code. Sie machen in einem Guava-Aufruf, was 2 mit den aktuellen Java-Sammlungen dauert.

Wenn du nicht kannst ...

Für eine unveränderliche Liste

Verwenden Sie die JDK-Klasse Arrays und die Methode asList() factory, die mit einer Collections.unmodifiableList() umschlossen ist:

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

Beachten Sie, dass der zurückgegebene Typ für asList() eine List ist, die eine konkrete ArrayList-Implementierung verwendet, aber es ist NICHTJava.util.ArrayList. Es ist ein innerer Typ, der eine ArrayList emuliert, tatsächlich aber direkt auf das übergebene Array verweist und dieses "durchschreiben" lässt (Änderungen werden im Array wiedergegeben).

Es verbietet Änderungen durch einige Methoden der List-API, indem einfach eine AbstractList erweitert wird (das Hinzufügen oder Entfernen von Elementen wird nicht unterstützt), jedoch können Aufrufe von set() zum Überschreiben von Elementen verwendet werden. Daher ist diese Liste nicht wirklich unveränderlich und ein Aufruf an asList() sollte mit Collections.unmodifiableList() abgeschlossen werden.

Siehe den nächsten Schritt, wenn Sie eine veränderliche Liste benötigen.

Für eine veränderliche Liste

Wie oben, jedoch mit einem tatsächlichen Java.util.ArrayList umschlossen:

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+

Für pädagogische Zwecke: Der gute alte Weg

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

Da diese Frage ziemlich alt ist, überrascht es mich, dass bisher noch niemand die einfachste Form vorgeschlagen hat:

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

Ab Java 5 verwendet Arrays.asList() einen varargs-Parameter, und Sie müssen das Array nicht explizit erstellen.

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

Stellen Sie sicher, dass myArray den gleichen Typ wie T hat. Sie erhalten einen Compiler-Fehler, wenn Sie beispielsweise versuchen, einen List<Integer> aus einem Array von int zu erstellen.

Ein anderer Weg (obwohl im Wesentlichen der Performance-Lösung von new ArrayList(Arrays.asList(array)) gleichwertig:

Collections.addAll(arraylist, array);

Java 9

In Java 9 können Sie die List.of static-Methode verwenden, um ein List-Literal zu erstellen. Etwas wie das Folgende:

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

Dies würde eine unveränderliche Liste mit drei Elementen zurückgeben. Wenn Sie eine mutable -Liste wünschen, übergeben Sie diese Liste an den Konstruktor ArrayList:

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

JEP 269: Convenience Factory-Methoden für Sammlungen

JEP 269 bietet einige praktische Factory-Methoden für Java Collections API. Diese unveränderlichen statischen Factory-Methoden sind in die Schnittstellen List , Set und Map in Java 9 und höher integriert.

Sie benötigen wahrscheinlich nur eine Liste, keine ArrayList. In diesem Fall können Sie einfach Folgendes tun:

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

Ein weiteres Update, das fast das Jahr 2014 beendet, ist auch mit Java 8 möglich:

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

Ein paar Zeichen würden gespeichert werden, wenn dies nur eine List sein könnte. 

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

Wenn du benutzt :

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

sie können erstellen und füllen zwei Listen! Wenn Sie zweimal eine große Liste ausfüllen, ist dies genau das, was Sie nicht tun möchten, da bei jeder Erweiterung der Kapazität ein weiteres Object[]-Array erstellt wird.

Glücklicherweise ist die JDK-Implementierung schnell und Arrays.asList(a[]) ist sehr gut gemacht. Es erstellt eine Art ArrayList mit dem Namen Arrays.ArrayList, bei der die Object [] - Daten direkt auf das Array zeigen.

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

Die gefährliche Seite ist das wenn Sie das ursprüngliche Array ändern, ändern Sie die Liste!Vielleicht ja vielleicht nein.

Wenn nicht, ist der verständlichste Weg dies zu tun:

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

Oder wie gesagt @glglgl, können Sie eine weitere unabhängige ArrayList erstellen mit:

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

Ich liebe es, Collections, Arrays oder Guava zu verwenden. Wenn es aber nicht passt oder Sie es nicht spüren, schreiben Sie stattdessen eine andere unelegante Zeile.

In Java 9 können Sie Folgendes verwenden:

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

Entsprechend der Frage lautet die Antwort mit Java 1.7:

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

Es ist jedoch besser, immer die Schnittstelle zu verwenden:

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

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

Sie können mit verschiedenen Methoden konvertieren

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

Weitere Informationen finden Sie unter http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-Java.html

Sie können dies auch mit Stream in Java 8 tun.

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

Seit Java 8 gibt es eine einfachere Möglichkeit zur Transformation:

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

wie gesagt, das wird so sein 

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

und der häufigste neueste Weg, ein Array zu erstellen, ist observableArrays.

ObservableList: Eine Liste, mit der Listener Änderungen verfolgen können, wenn sie auftreten.

für Java SE können Sie es versuchen 

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

das ist nach Oracle Docs

observableArrayList () Erzeugt eine neue leere beobachtbare Liste, die von einer Arrayliste unterstützt wird . observableArrayList (E ... Elemente) Erzeugt eine neue Liste beobachtbarer Arrays mit hinzugefügten Elementen.

Java 9 aktualisieren

auch in Java 9 ist es ein bisschen einfach:

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

1. Wenn wir die Definition der Arrays.asList()-Methode sehen, erhalten Sie etwa Folgendes: 

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

   So können Sie arraylist folgendermaßen initialisieren: 

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

   Hinweis : Jedes new Element(int args) wird als Einzelobjekt behandelt und kann als var-args übergeben werden.

2. Es könnte auch eine andere Antwort auf diese Frage geben.
   Wenn Sie eine Deklaration für die Java.util.Collections.addAll()-Methode sehen, erhalten Sie etwa Folgendes:

   public static <T> boolean addAll(Collection<? super T> c, T... a);
   

   Daher ist dieser Code auch dazu nützlich

   Collections.addAll(arraylist, array);
   

Eine andere einfache Möglichkeit besteht darin, alle Elemente aus dem Array mithilfe einer for-each-Schleife zu einer neuen ArrayList hinzuzufügen.

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

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

Wenn das Array einen primitiven Typ hat, funktionieren die angegebenen Antworten nicht. Aber seit Java 8 können Sie Folgendes verwenden:

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

Wir können ein Array leicht in ArrayList..__ konvertieren. Wir verwenden die addAll()-Methode der Collection-Schnittstelle, um Inhalte von einer Liste in eine andere zu kopieren. 

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

Verwenden Sie den folgenden Code, um ein Elementarray in eine ArrayList zu konvertieren. 

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

Obwohl es viele perfekt geschriebene Antworten auf diese Frage gibt, werde ich meine Eingaben hinzufügen. 

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

Neue ArrayList kann auf folgende Weise erstellt werden

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

Und sie unterstützen sehr gut alle Operationen von 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

Die folgenden Vorgänge geben jedoch nur eine Listenansicht einer ArrayList und keine tatsächliche ArrayList zurück.

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

Sie geben daher einen Fehler aus, wenn Sie versuchen, einige ArrayList-Vorgänge auszuführen

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

Mehr zu Listendarstellung von Array Link .

Bereits hat jeder genug gute Antwort für Ihr Problem zur Verfügung gestellt. Nun müssen Sie aus allen Vorschlägen entscheiden, welche Ihren Anforderungen entsprechen. Es gibt zwei Arten von Sammlungen, die Sie kennen müssen. Eine ist die unveränderte Sammlung und eine andere Sammlung, mit der Sie das Objekt später ändern können.

Also, hier werde ich ein kurzes Beispiel für zwei Anwendungsfälle geben.

• Erstellung unveränderlicher Sammlungen: Wenn Sie das Sammlungsobjekt nach der Erstellung nicht ändern möchten

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

• Erstellung einer veränderlichen Sammlung :: Wenn Sie das erstellte Sammlungsobjekt nach der Erstellung möglicherweise ändern möchten.

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

Am einfachsten ist es, folgenden Code hinzuzufügen. Ausprobiert und getestet.

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

Eine andere Java8-Lösung (Ich habe die Antwort unter der großen Gruppe möglicherweise verpasst. Wenn ja, entschuldige ich mich). Dies erstellt eine ArrayList (im Gegensatz zu einer Liste), d. H. Man kann Elemente löschen

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

Ausgabe ist ... 
Hallo 
Welt

Sie können dies in Java 8 wie folgt tun

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

Sie können eine ArrayList mit Cactoos erstellen (ich bin einer der Entwickler):

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

Es gibt keine Garantie dafür, dass das Objekt tatsächlich die Klasse ArrayList ist. Wenn Sie diese Garantie benötigen, tun Sie dies:

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

Verwenden Sie den folgenden Code

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

der Lambda-Ausdruck, der eine Liste vom Typ generiertArrayList<Element>
(1) ohne ungeprüfte Besetzung
(2) ohne eine zweite Liste zu erstellen (mit zB asList())

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

Die Arrays-Klasse von Java 8 bietet eine stream () -Methode, deren überladene Versionen sowohl primitive Arrays als auch Object-Arrays akzeptieren.

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

Hier sind die 3 Möglichkeiten .. kann nützlich sein,

    Arrays.asList("yellow", "green","blue");

    Collections.singletonList(new String[]{"yellow", "green","blue"});

    Arrays.stream((new String[]{"yellow", "green", "blue"})).collect(Collectors.toList());

Das ist ein klarer Weg dafür

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