Erstellen Sie ArrayList aus Array

3596

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 = ???;
Ron Tuffin
quelle
49
In Java9 -> List <String> list = List.of ("Hallo", "Welt", "von", "Java");
MarekM
18
@MarekM Diese Antwort ist falsch, da dies keine zurückgibt ArrayList. Das Poster hat speziell danach gefragt.
Dorian Gray
4
Ich denke, er hat meine List-Oberfläche nicht verwendet, da dies die beste Vorgehensweise ist. Aber wenn Sie hier wollen, ist - neue ArrayList <> (List.of ("Hallo", "Welt", "von", "Java"));
MarekM
10
Es geht nicht darum, die Schnittstelle zu verwenden, sondern darum, dass die zurückgegebene Liste in Ihrer Lösung nicht geändert werden kann. Das könnte eher ein Problem sein und ein Grund, warum er nach einer ArrayList gefragt hat
Dorian Gray

Antworten:

4603
new ArrayList<>(Arrays.asList(array));
Tom
quelle
361
Ja. Und in dem (häufigsten) Fall, in dem Sie nur eine Liste wünschen, ist der new ArrayListAnruf ebenfalls nicht erforderlich.
Calum
143
@Luron - nur verwendenList<ClassName> list = Arrays.asList(array)
Pool
248
@Calum und @Pool - wie unten in Alex Millers Antwort angegeben, wird die Größe der Liste festgelegt, wenn Sie sie verwenden, Arrays.asList(array)ohne sie an ein neues ArrayListObjekt zu übergeben. Einer der häufigsten Gründe für die Verwendung von a ArrayListist die dynamische Änderung seiner Größe. Ihr Vorschlag würde dies verhindern.
Code Jockey
130
Arrays.asList () ist eine schreckliche Funktion, und Sie sollten den Rückgabewert niemals so verwenden, wie er ist. Die Listenvorlage wird beschädigt. Verwenden Sie sie daher immer in der hier angegebenen Form, auch wenn sie redundant erscheint. Gute Antwort.
Adam
83
@Adam Bitte studieren Sie das Javadoc für java.util.List. Der Vertrag für das Hinzufügen ermöglicht es ihnen, eine UnsupportedOperationException auszulösen. docs.oracle.com/javase/7/docs/api/java/util/… Zugegeben, aus objektorientierter Sicht ist es nicht sehr schön, dass man die konkrete Implementierung oft kennen muss, um eine Sammlung zu verwenden - dies war eine pragmatische Designentscheidung, um das Framework einfach zu halten.
lbalazscs
918

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.
Alex Miller
quelle
6
Was ist die zeitliche Komplexität beider Operationen? Ich meine mit und ohne explizite Arraylistenkonstruktion.
Verdammt
35
Arrays.asList () erstellt lediglich eine ArrayList, indem das vorhandene Array so umbrochen wird, dass es O (1) ist.
Alex Miller
27
Das Umschließen einer neuen ArrayList () bewirkt, dass alle Elemente der Liste mit fester Größe iteriert und der neuen ArrayList hinzugefügt werden, also O (n).
Alex Miller
8
Die von asList () zurückgegebene Implementierung von List implementiert nicht mehrere Methoden von List (wie add (), remove (), clear () usw.), was die UnsupportedOperationException erklärt. definitiv eine Einschränkung ...
Sethro
8
Wenn die Frage nach "einem Objekt der ArrayList-Klasse" fragt, ist es meiner Meinung nach vernünftig anzunehmen, dass die Klasse, auf die sie sich bezieht, ist java.util.ArrayList. Arrays.asList gibt tatsächlich eine zurück, java.util.Arrays.ArrayListdie keine instanceofandere Klasse ist. Eine dritte Einschränkung ist also, dass es nicht funktioniert, wenn Sie versuchen, es in einem Kontext zu verwenden, der dies erfordert.
Dave L.
352

(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);
}
Haylem
quelle
27
+1 Beachten Sie jedoch, dass das Listzurückgegebene von Arrays.asListveränderbar ist, da Sie weiterhin setElemente verwenden können - es kann nur nicht in der Größe geändert werden. Für unveränderliche Listen ohne Guave könnten Sie erwähnen Collections.unmodifiableList.
Paul Bellora
1
@haylem In Ihrem Abschnitt Für Bildungszwecke: Der gutearrayToList alte manuelle Weg ist Ihr für Java 1.5+ falsch. Sie instanziieren Listen von Stringund versuchen, Zeichenfolgen aus dem angegebenen Array abzurufen, anstatt den generischen Parametertyp zu verwenden T. Davon abgesehen eine gute Antwort und +1 für die einzige, die den manuellen Weg einschließt.
Afsantos
Ich benenne deinen Abschnitt "Wenn du nicht kannst ... / Für eine unveränderliche Liste" in "Für eine nicht veränderbare Liste" um, da er durch spätere Änderungen am umschlossenen Array mutiert werden kann. Es ist immer noch so O(1), aber für Unveränderlichkeit müssen Sie eine Kopie erstellen, z Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))).
Maaartinus
232

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.

Tim Büthe
quelle
7
InsbesondereList<String> a = Arrays.asList("first","second","third")
18446744073709551615
209
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.

Bill die Eidechse
quelle
103

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

Collections.addAll(arraylist, array);
Peter Tseng
quelle
96

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.

Ali Dehghani
quelle
List.of () gibt keine Instanz von java.util.ArrayList zurück, wie in der ursprünglichen Frage angefordert. Daher ist nur die zweite Option eine gültige Antwort.
Tquadrat
84

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

List<Element> arraylist = Arrays.asList(array);
Pennen
quelle
8
Dies wird durch das ursprüngliche Eingabearray unterstützt, weshalb Sie es (wahrscheinlich) in eine neue ArrayList einschließen möchten.
Bill the Lizard
16
Seien Sie vorsichtig mit dieser Lösung. Wenn Sie schauen, geben Arrays KEINE echte java.util.ArrayList zurück. Es wird eine innere Klasse zurückgegeben, die die erforderlichen Methoden implementiert, aber Sie können die Mitglieder in der Liste nicht ändern. Es ist lediglich ein Wrapper um ein Array.
Mikezx6r
1
Sie können das List <Element>
-Element
12
@ Mikezx6r: kleine Korrektur : Es ist eine Liste mit fester Größe. Sie können die Elemente der Liste ( setMethode) ändern, Sie können die Größe der Liste (nicht addoder removeElemente) nicht ändern !
user85421
1
Ja, mit der Einschränkung, dass es davon abhängt, was Sie mit der Liste machen möchten. Es ist erwähnenswert, dass das Array überhaupt nicht konvertiert werden muss, wenn das OP nur die Elemente durchlaufen möchte.
Paul MurrayCbr
69

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());
warum
quelle
8
Es ist wahrscheinlich am besten, nicht implementierungsabhängig zu sein, sondern Collectors.toList()tatsächlich eine zurückzugeben ArrayList.
bcsb1001
falsche Verwendung von Stream.of (...); Dadurch wird ein Ein-Element-Stream erstellt. Verwenden Sie stattdessen Arrays.stream
Patrick Parker
Ich denke nicht, die 2 Optionen sind gültig, aber der Arrays.stream ist etwas 'besser', da Sie ihn mit fester Größe erstellen können, indem Sie die Überladungsmethode mit 'start', 'end' args verwenden. Siehe auch: stackoverflow.com/a/27888447/2619091
whyem
41

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.

Nicolas Zozol
quelle
1
Ich sehe keinen grundlegenden Unterschied zwischen Ihrer Schleife am Ende der Antwort und dem new ArrayList<T>(Arrays.asList(myArray));Teil, von dessen Verwendung Sie abraten. Beide machen das gleiche und haben die gleiche Komplexität.
glglgl
Die Sammlungen erstellen einen Zeiger am Anfang des Arrays. Meine Schleife erstellt viele Zeiger: einen für jedes Array-Mitglied. Wenn sich also das ursprüngliche Array ändert, sind meine Zeiger immer noch auf die vorherigen Werte gerichtet.
Nicolas Zozol
1
new ArrayList<T>(Arrays.asList(myArray));macht das gleiche, es kopiert das asListzu einem ArrayList...
glglgl
37

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);
MarekM
quelle
Beachten Sie, dass dies keine ArrayList ist, da dies ausdrücklich abgefragt wurde.
Dorian Gray
33

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);
nekperu15739
quelle
30
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 
Bohdan
quelle
21

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");
Abojemyeg
quelle
20

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());
}
Andrii Abramov
quelle
18

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

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 
Vaseph
quelle
3
Ab Java 8 , Collectors.toList()wird eine Rückkehr ArrayList. Dies kann jedoch in zukünftigen Versionen von Java unterschiedlich sein. Wenn Sie einen bestimmten Sammlungstyp möchten, verwenden Sie Collectors.toCollection()stattdessen, wo Sie angeben können, welchen genauen Sammlungstyp Sie erstellen möchten.
Raja Anbazhagan
14
  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);
Vikrant Kashyap
quelle
10

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);
spencer.sm
quelle
10

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());
A1m
quelle
Diese Lösung scheint auch nicht mit charArray zu funktionieren .
PixelMaster
8

Sie können dies in Java 8 wie folgt tun

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
Stollen Sie A. Pillai
quelle
1
Abgestimmt, weil diese Besetzung sehr gefährlich aussieht. Nichts gibt an, dass der zurückgegebene Listentyp tatsächlich eine ArrayList ist, wie im Javadoc angegeben: "Es gibt keine Garantien für den Typ, die Veränderlichkeit, die Serialisierbarkeit oder die Thread-Sicherheit der zurückgegebenen Liste"
Dorian Gray
1
Wenn Sie eine ArrayList explizit erstellen möchten, versuchen Sie ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
Dorian Gray
8

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));
Hautausschläge
quelle
Dies ist weniger effizient als die akzeptierte 9 Jahre alte Antwort.
AjahnCharles
2
Einer der ArrayListKonstruktoren akzeptiert ein ? extends Collection<T>Argument und macht den Aufruf von addAllredundant.
Tamoghna Chowdhury
7

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 .

Devendra Lattu
quelle
7

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

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

Zahnloser Seher
quelle
7

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]);
}
Kavinda Pushpitha
quelle
5

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

Sumit Das
quelle
List <Element> elementList = Arrays.asList (Array) erstellt einen Wrapper über dem ursprünglichen Array, der das ursprüngliche Array als List verfügbar macht. Daher wird ein Wrapper-Objekt erstellt, nichts wird vom ursprünglichen Array kopiert. Daher sind Vorgänge wie das Hinzufügen oder Entfernen von Elementen nicht zulässig.
Priyanka
3
Beachten Sie, dass Ihre "unveränderliche Sammlung" nicht wirklich unveränderlich ist - die Listzurückgegebene Sammlung Arrays.asListist nur ein Wrapper über dem ursprünglichen Array und ermöglicht den Zugriff auf und die Änderung einzelner Elemente über getund set. Sie sollten wahrscheinlich klarstellen, dass Sie "keine Elemente hinzufügen oder entfernen" anstelle von "unveränderlich" meinen, was bedeutet, dass Sie sich überhaupt nicht ändern.
Tamoghna Chowdhury
5

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

Arpan Saini
quelle
4

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());
Himanshu Dave
quelle
3

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

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