Ich habe ein Array, das wie folgt initialisiert wird:

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

Ich möchte dieses Array in ein Objekt der ArrayListKlasse konvertieren .

ArrayList<Element> arraylist = ???;

new ArrayList<>(Arrays.asList(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);

Dies wird gut funktionieren. Aber einige Einschränkungen:

1. Die von asList zurückgegebene Liste hat eine 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 Liste einschließen ArrayList. Andernfalls erhalten Sie eine UnsupportedOperationException.
2. Die von asList()zurückgegebene Liste wird vom ursprünglichen Array unterstützt. Wenn Sie das ursprüngliche Array ändern, wird auch die Liste geändert. Dies kann überraschend sein.

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

Wenn Sie können, verwenden Sie Guave

Es lohnt sich, auf den Guaven-Weg hinzuweisen, der diese Spielereien erheblich vereinfacht:

Verwendungszweck

Für eine unveränderliche Liste

Verwenden Sie die ImmutableListKlasse 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änderbare Liste

Verwenden Sie die ListsKlasse 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

Bitte beachten Sie auch die ähnlichen Methoden für andere Datenstrukturen in anderen Klassen, zum Beispiel in Sets.

Warum Guave?

Die Hauptattraktion könnte darin bestehen, die Unordnung aufgrund von Generika für die Typensicherheit zu verringern, da durch die Verwendung der Guava- Fabrikmethoden die Typen die meiste Zeit abgeleitet werden können. Dieses Argument enthält jedoch weniger Wasser, da Java 7 mit dem neuen Diamantoperator eingetroffen ist.

Dies ist jedoch nicht der einzige Grund (und Java 7 ist noch nicht überall): Die Kurzschrift-Syntax ist ebenfalls sehr praktisch, und die oben beschriebenen Methodeninitialisierer ermöglichen das Schreiben von aussagekräftigerem Code. Sie tun in einem Guava-Aufruf, was mit den aktuellen Java-Sammlungen 2 dauert.

Wenn Sie nicht können ...

Für eine unveränderliche Liste

Verwenden Sie die ArraysKlasse des JDK und seine asList()Factory-Methode, die mit einem Collections.unmodifiableList():

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 Listkonkrete Verwendung ArrayListImplementierung, aber es ist nicht java.util.ArrayList . Es ist ein innerer Typ, der ein emuliertes ArrayListArray emuliert, aber tatsächlich direkt auf das übergebene Array verweist und es zum "Durchschreiben" bringt (Änderungen werden im Array wiedergegeben).

Es verbietet Änderungen durch einige der ListAPI-Methoden durch einfaches Erweitern von a AbstractList(daher wird das Hinzufügen oder Entfernen von Elementen nicht unterstützt), ermöglicht jedoch Aufrufen, set()Elemente zu überschreiben. Daher ist diese Liste nicht wirklich unveränderlich und ein Aufruf an asList()sollte mit abgeschlossen werden Collections.unmodifiableList().

Lesen Sie den nächsten Schritt, wenn Sie eine veränderbare Liste benötigen.

Für eine veränderbare Liste

Wie oben, jedoch mit einem tatsächlichen 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+

Für Bildungszwecke: Der gute alte manuelle 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 noch niemand die einfachste Form vorgeschlagen hat:

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

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

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

Stellen Sie sicher, dass dies myArrayder gleiche Typ ist wie T. Sie erhalten einen Compilerfehler, wenn Sie beispielsweise versuchen, einen List<Integer>aus einem Array von zu erstellen int.

Ein anderer Weg (obwohl er im Wesentlichen der new ArrayList(Arrays.asList(array))Leistung der Lösung entspricht :

Collections.addAll(arraylist, array);

Java 9

In Java 9 können Sie die List.ofstatische Factory-Methode verwenden, um ein ListLiteral zu erstellen . So 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 zurückgeben, die drei Elemente enthält. Wenn Sie eine veränderbare Liste wünschen , übergeben Sie diese Liste an den ArrayListKonstruktor:

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

JEP 269: Convenience Factory-Methoden für Sammlungen

JEP 269 bietet einige praktische Factory-Methoden für die Java Collections- API. Diese unveränderlichen statischen Factory - Methoden werden in denen gebaut List, Setund MapSchnittstellen in Java 9 und höher.

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, können Sie auch mit Java 8 durchführen:

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

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

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

Wenn du benutzt :

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

Sie können zwei Listen erstellen und füllen ! Das zweimalige Ausfüllen einer großen Liste ist genau das, was Sie nicht tun möchten, da Object[]jedes Mal, wenn die Kapazität erweitert werden muss, ein weiteres Array erstellt wird.

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

// 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, dass Sie die Liste ändern , wenn Sie das ursprüngliche Array ändern! Bist du sicher, dass du das willst? Vielleicht ja vielleicht nein.

Wenn nicht, ist dies am verständlichsten:

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 zu verwenden Collections, Arraysoder Guave. Aber wenn es nicht passt oder Sie es nicht fühlen, schreiben Sie stattdessen einfach eine andere unelegante Zeile.

In können Java 9Sie 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));

Verwenden Sie jedoch besser immer die Schnittstelle:

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

Wie alle sagten, wird dies so sein

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

und die gebräuchlichste neueste Methode zum Erstellen von Arrays sind beobachtbare Arrays

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

für Java SE können Sie versuchen

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

das ist nach Oracle Docs

ObservableArrayList () Erstellt eine neue leere Observable-Liste, die von einer Arrayliste unterstützt wird. ObservableArrayList (E ... items) Erstellt eine neue Observable-Array-Liste mit hinzugefügten Elementen.

Aktualisieren Sie Java 9

auch in Java 9 ist es ein bisschen einfach:

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

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

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

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

1. Wenn wir die Definition der Arrays.asList()Methode sehen, erhalten Sie ungefähr Folgendes:

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

   Sie können also folgendermaßen initialisieren arraylist:

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

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

2. Möglicherweise gibt es auch eine andere Antwort auf diese Frage.
   Wenn Sie eine Deklaration für die java.util.Collections.addAll()Methode sehen, erhalten Sie ungefähr Folgendes:

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

   Daher ist dieser Code auch nützlich, um dies zu tun

   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 vom primitiven Typ ist, funktionieren die angegebenen Antworten nicht. Aber seit Java 8 können Sie verwenden:

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

Sie können dies in Java 8 wie folgt tun

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

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

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

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

Daher geben sie Fehler aus, wenn sie versuchen, einige ArrayList-Operationen durchzuführen

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

Weitere Informationen zur Listendarstellung des Array- Links .

Der einfachste Weg, dies zu tun, ist das Hinzufügen des folgenden Codes. Ausprobiert und getestet.

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

Eine andere Java8-Lösung (möglicherweise habe ich die Antwort in der großen Gruppe verpasst. Wenn ja, entschuldige ich mich). Dadurch wird eine ArrayList erstellt (im Gegensatz zu einer Liste), dh 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

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

Jeder hat bereits genug gute Antworten auf Ihr Problem gegeben. Aus allen Vorschlägen müssen Sie nun entscheiden, welche Ihren Anforderungen entspricht. Es gibt zwei Arten von Sammlungen, die Sie kennen müssen. Eine ist eine unveränderte Sammlung und eine andere Sammlung, mit der Sie das Objekt später ändern können.

Hier werde ich ein kurzes Beispiel für zwei Anwendungsfälle geben.

• Unveränderliche Sammlungserstellung :: Wenn Sie das Sammlungsobjekt nach der Erstellung nicht ändern möchten

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

• Erstellung veränderbarer Sammlungen :: Wenn Sie das erstellte Sammlungsobjekt nach der Erstellung ändern möchten.

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

Gegebenes Objektarray:

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

Array in Liste konvertieren:

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

Konvertieren Sie Array in ArrayList

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

Array in LinkedList konvertieren

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

Liste drucken:

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

AUSGABE

1

2

3

Die Arrays-Klasse von Java 8 bietet eine stream () -Methode, bei der Versionen überladen sind, die 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());

Der folgende Code scheint eine gute Möglichkeit zu sein, dies zu tun.

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