ArrayList aus Array erstellen

Question

Ich habe ein Array, das wie initialisiert wird:

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

Ich möchte dieses Array in ein Objekt des Typs ArrayList Klasse.

ArrayList<Element> arraylist = ???;

Answer 1

new ArrayList<>(Arrays.asList(array));

Answer 2

Gegeben:

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

Die einfachste Antwort ist zu tun:

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 in der Lage sein wollen, in Ihrem Code Elemente aus der zurückgegebenen Liste hinzuzufügen oder zu entfernen, müssen Sie sie in eine neue ArrayList . Andernfalls erhalten Sie eine UnsupportedOperationException .
2. Die Liste, die von asList() wird durch das ursprüngliche Array unterstützt. Wenn Sie das ursprüngliche Array ändern, wird auch die Liste geändert. Dies mag überraschend sein.

Answer 3

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

Wenn möglich, verwenden Sie Guave

Es lohnt sich, auf die Guava-Methode hinzuweisen, die diesen Blödsinn erheblich vereinfacht:

Verwendung

Für eine unveränderliche Liste

Verwenden Sie die ImmutableList Klasse und ihre of() y copyOf() Fabrikmethoden (Elemente können 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 Lists Klasse und ihre newArrayList() Fabrikmethoden:

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 Unübersichtlichkeit aufgrund von Generika für die Typsicherheit zu verringern, da die Verwendung des Guava Fabrikmethoden lassen sich die Typen in den meisten Fällen ableiten. Dieses Argument ist jedoch weniger stichhaltig, seit Java 7 mit dem neuen Diamant-Operator ausgestattet ist.

Aber das ist nicht der einzige Grund (und Java 7 ist noch nicht überall angekommen): die Kurzsyntax ist auch sehr praktisch, und die Methodeninitialisierer, wie oben gesehen, erlauben es, ausdrucksvolleren Code zu schreiben. Sie tun in einem Guava-Aufruf, was mit den aktuellen Java Collections 2 dauert.

---

Wenn du nicht kannst...

Für eine unveränderliche Liste

Verwenden Sie die JDK-Funktion Arrays Klasse und ihre asList() Factory-Methode, umhüllt von einer 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() ist eine List mit einer konkreten ArrayList Umsetzung, sondern es ist NICHT java.util.ArrayList . Es handelt sich um einen inneren Typ, der eine ArrayList sondern verweist direkt auf das übergebene Array und macht es "durchschreibbar" (Änderungen werden in das Array übernommen).

Sie verbietet Änderungen durch einige der List API-Methoden durch die einfache Erweiterung einer AbstractList (das Hinzufügen oder Entfernen von Elementen wird also nicht unterstützt), aber es erlaubt Aufrufe an set() um Elemente außer Kraft zu setzen. Daher ist diese Liste nicht wirklich unveränderlich und ein Aufruf von asList() sollte umhüllt sein mit Collections.unmodifiableList() .

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

Für eine veränderliche Liste

Dasselbe wie oben, aber mit einer 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: Das gute alte Handbuch

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

Answer 4

Da diese Frage schon 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, Arrays.asList() nimmt einen varargs-Parameter und Sie müssen das Array nicht explizit konstruieren.

Answer 5

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

Stellen Sie sicher, dass myArray ist der gleiche Typ wie T . Sie erhalten einen Compilerfehler, wenn Sie versuchen, eine List<Integer> aus einer Reihe von int zum Beispiel.