Frage Erstellen ArrayList aus Array


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 ArrayList-Klasse konvertieren.

ArrayList<Element> arraylist = ???;

2963
2017-10-01 14:38


Ursprung


Antworten:


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

3962
2017-10-01 14:39



Gegeben:

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

Die einfachste Antwort ist:

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 aus der zurückgegebenen Liste in Ihrem Code hinzufügen oder entfernen möchten, müssen Sie sie in eine neue umbrechen ArrayList. Sonst bekommst du ein UnsupportedOperationException.
  2. Die Liste stammt von asList() wird vom ursprünglichen Array unterstützt. Wenn Sie das ursprüngliche Array ändern, wird auch die Liste geändert. Dies kann überraschend sein.

774
2017-10-01 15:39



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

Wenn Sie können, Guava verwenden

Es lohnt sich, auf den Guava-Weg hinzuweisen, der diese Spielereien wesentlich vereinfacht:

Verwendung

Für eine unveränderbare Liste

Benutze die ImmutableList Klasse und seine of() und 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

Benutze die Lists Klasse und seine 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 Guava?

Die Hauptattraktion könnte darin bestehen, das Durcheinander durch Generika für die Typensicherheit zu reduzieren, wie die Verwendung der Guave Fabrikmethoden lassen Sie zu, dass die Typen die meiste Zeit abgelesen werden. Dieses Argument enthält jedoch weniger Wasser, seit Java 7 mit dem neuen Diamantenoperator eingetroffen ist.

Aber es ist nicht der einzige Grund (und Java 7 ist noch nicht überall): Die Kurzschriftsyntax ist auch sehr praktisch, und die Methoden-Initialisierer, wie oben gezeigt, erlauben es, ausdrucksstarkeren Code zu schreiben. Sie machen in einem Guava-Aufruf, was bei den aktuellen Java-Sammlungen 2 annimmt.


Wenn du nicht kannst ...

Für eine unveränderbare Liste

Verwenden Sie die JDKs Arrays Klasse und seine asList() Fabrikmethode, eingewickelt 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() ist ein List mit einem Beton ArrayList Implementierung, aber es ist nicht  java.util.ArrayList. Es ist ein innerer Typ, der einem nacheifert ArrayList verweist aber direkt auf das übergebene Array und bewirkt, dass es "durchschreibt" (Änderungen werden im Array widergespiegelt).

Es verbietet Modifikationen durch einige der List API-Methoden durch einfaches Erweitern eines AbstractList (Das Hinzufügen oder Entfernen von Elementen wird also nicht unterstützt.) set() Elemente überschreiben Somit ist diese Liste nicht wirklich unveränderbar und ein Aufruf an asList() sollte mit gewickelt werden Collections.unmodifiableList().

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

Für eine änderbare Liste

Gleich wie oben, aber mit einem tatsächlichen umwickelt 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 pädagogische Zwecke: 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);
}

295
2017-11-16 17:16



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, Arrays.asList() nimmt einen Varargs-Parameter und Sie müssen das Array nicht explizit erstellen.


203
2018-06-22 11:30



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

Stelle sicher das myArray ist der gleiche Typ wie T. Sie erhalten einen Compiler-Fehler, wenn Sie versuchen, ein List<Integer>aus einer Reihe von int, beispielsweise.


172
2017-10-01 14:40



Ein anderer Weg (obwohl im Wesentlichen gleichbedeutend mit der new ArrayList(Arrays.asList(array)) Lösung leistungsmäßig:

Collections.addAll(arraylist, array);

77
2018-04-03 23:20



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

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

62
2017-10-01 14:45



Java 9

Im Java 9kannst du benutzen List.of statische Factory-Methode, um ein List wörtlich. Etwas wie das Folgende:

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

Dies würde ein zurückgeben unveränderlich Liste mit drei Elementen. Wenn du willst veränderlich Liste, übergebe diese Liste an die ArrayList Konstrukteur:

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

JEP 269: Convenience-Factory-Methoden für Sammlungen

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


59
2018-04-17 16:58



Ein weiteres Update, das fast im Jahr 2014 endet, kannst du auch mit Java 8 machen:

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

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

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

54
2017-11-25 20:48



Um ein Array in eine ArrayList zu konvertieren, tun Entwickler dies oft:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() wird eine ArrayList zurückgeben, die a ist private static class inside ArraysEs ist nicht die Klasse java.util.ArrayList. The java.util.Arrays.ArrayList Klasse hat set(), get(), contains() Methoden, aber hat keine Methoden zum Hinzufügen von Elementen, so dass seine Größe festgelegt ist. Um eine echte ArrayList zu erstellen, müssen Sie Folgendes tun:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

Der Konstruktor von ArrayList kann a akzeptieren Sammlungsart, das ist auch ein Super-Typ für java.util.Arrays.ArrayList


47
2018-06-25 07:20