So erstellen Sie eine neue Liste in Java

762

Wir erstellen ein Setals:

Set myset = new HashSet()

Wie erstellen wir eine Listin Java?

user93796
quelle
1
Auf dem Javadoc für List. "Alle bekannten implementierenden Klassen: AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector"
KitsuneYMG
121
Diese Frage ist einer der Top-Google-Hits für "Java Create List" und hat eine sehr hilfreiche Reihe von Antworten, so scheint mir eine vernünftige Frage :-)
JosephH
52
Es ist eine gute Frage mit guten Antworten. Eines der Ziele von Stack Overflow ist es, zumindest nach Ansicht der Gründer der Site eine kanonische Antwort auf Programmierfragen zu erstellen. Versuchen Sie also bitte, solche Posts in Zukunft nicht mehr herunterzustimmen, wenn Sie der Versuchung widerstehen können.
Eierbeine

Antworten:

977
List myList = new ArrayList();

oder mit Generika ( Java 7 oder höher)

List<MyType> myList = new ArrayList<>();

oder mit Generika (alte Java-Versionen)

List<MyType> myList = new ArrayList<MyType>();
Dan Vinton
quelle
68
Beachten Sie, dass ArrayList nicht die einzige Art von Liste ist - und in Bezug auf die Frage ist HashSet nicht die einzige Art von Set.
schlank
17
Ich bin überrascht, dass niemand erwähnt hat, dass Sie die Listenschnittstelle in der Java-Dokumentation nachschlagen können, um eine eindeutige Liste aller Klassen zu erhalten, die List implementieren: docs.oracle.com/javase/7/docs/api/java/util /List.html
David Mason
5
Wenn Sie eine IDE verwenden, können Sie dort im Allgemeinen auch eine Typhierarchie anzeigen, was möglicherweise praktischer ist. In Eclipse ist die Standardverknüpfung F4 und in IDEA Strg + H.
David Mason
1
Soweit
5
Das zweite explizite Typargument <MyType> kann für Java 7 und 8 durch nur <> ersetzt werden.
Jannik
469

Wenn Sie außerdem eine Liste erstellen möchten, die Elemente enthält (obwohl die Größe festgelegt ist):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
Aaron Maenpaa
quelle
15
Die Einschränkung ist, dass diese Art von Liste (die von asList () zurückgegebene) unveränderlich ist.
Avrom
70
@ Avron - falsch: es ist nur feste Größe: Sie können die Größe nicht ändern, aber Sie können den Inhalt ändern (Einschränkung der Einschränkung?)
user85421
Genial. Vielen Dank für Ihre Prägnanz.
R Claven
1
Wenn die Liste nur eines enthält, verwende ich Collections.singletonList () anstelle von Arrays.asList (). (Aber ich denke, ich weiß nicht warum.)
MikeB
@ MikeB Wenn Sie nicht wissen warum, dann bleiben Sie bei der arrays.aslist
bharal
183

Lassen Sie mich etwas zusammenfassen und hinzufügen:

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

Guave

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

Unveränderliche Liste

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      // Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  // Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

Leere unveränderliche Liste

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

Liste der Zeichen

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

Liste der ganzen Zahlen

Ints.asList(1,2,3);                                             // Guava
Sergii Shevchyk
quelle
Ints.asListerstellt keine unveränderliche Liste, sondern eine Liste mit fester Größe, die von einem bestimmten Array von Ints unterstützt wird (dh unterstützt wird List.set(int, Object)). Das zweite Beispiel für "Unveränderliche Liste von Zeichen" ist ebenfalls nicht unveränderlich (ich würde diese Zeile entfernen).
Xaerxess
9
Wenn Sie keine Generika verwenden, ist dies ein wirklich "gutes" Beispiel für jeden Entwickler, der dies liest.
Natix
60

In Java 8

So erstellen Sie eine nicht leere Liste mit fester Größe (Vorgänge wie Hinzufügen, Entfernen usw. werden nicht unterstützt):

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

So erstellen Sie eine nicht leere veränderbare Liste:

List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));

In Java 9

Verwenden einer neuen List.of(...)statischen Factory-Methode:

List<Integer> immutableList = List.of(1, 2);

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

In Java 10

Verwenden der Inferenz des lokalen Variablentyps :

var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

Und befolgen Sie Best Practices ...

Verwenden Sie keine rohen Typen

Seit Java 5 sind Generika ein Teil der Sprache - Sie sollten sie verwenden:

List<String> list = new ArrayList<>(); // Good, List of String

List list = new ArrayList(); // Bad, don't do that!

Programm zu Schnittstellen

Zum Beispiel auf die ListSchnittstelle programmieren:

List<Double> list = new ArrayList<>();

Anstatt:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!
Oleksandr Pyrohov
quelle
1
Hallo, können Sie bitte vorschlagen, wo ich diese Unterschiede und die Entwicklung von Java lernen kann? Scheint sehr interessant!
Shiv
31

Lesen Sie dies zuerst , dann lesen Sie dies und das . 9 mal von 10 verwenden Sie eine dieser beiden Implementierungen.

Lesen Sie einfach den Sun-Leitfaden zum Sammlungs-Framework .

Adam Jaskiewicz
quelle
11
Ich würde sogar "8 mal von 10" hinzufügen, Sie werden ArrayList verwenden, nur weil es in 9,9 mal von 10 einfach keine Rolle spielt.
Joachim Sauer
1
LinkedList ist semantisch angemessen, wenn Sie sich nur wirklich um die Ziele kümmern.
Adam Jaskiewicz
LinkedLists eignen sich hervorragend, wenn Sie sie nur durchlaufen möchten. Für mich scheint es, als ob verknüpfte Listen eleganter sind, aber vielleicht liegt es nur daran, dass ich vor Java Lisp gelernt habe.
KarlP
@ Karlp Einverstanden. Ich würde sagen, dass es zwischen ArrayList und LinkedList die meiste Zeit ungefähr 50/50 ist, und die Antwort bezieht sich nicht immer auf die Komplexität der Operationen. öfter ist es einfach das, was sich für das vorliegende Problem richtig anfühlt.
Adam Jaskiewicz
1
Ich habe fast immer benutzt ArrayList. Wenn ich nur mit den Enden einer Liste arbeite, ist es eine Deque (oder Warteschlange) und ich verwende die ArrayDequeImplementierung. Der Grund dafür ist, dass obwohl die Array-basierten Implementierungen möglicherweise Speicherplatz in leeren Slots verschwenden (wenn ich die erforderliche Kapazität nicht vorhersagen kann), dies für kleine Sammlungen mit dem Overhead aller Knoteninstanzen in einer verknüpften Liste vergleichbar ist ( oder deque). Und im Gegenzug bekomme ich zufälligen Zugriff. Welchen einzigartigen Vorteil bietet LinkedListes?
erickson
21
//simple example creating a list form a string array

String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};

List mylist = Arrays.asList(myStrings );

//getting an iterator object to browse list items

Iterator itr= mylist.iterator();

System.out.println("Displaying List Elements,");

while(itr.hasNext())

  System.out.println(itr.next());
Blerta
quelle
21

Seit Java 7 haben Sie eine Typinferenz für die Erstellung generischer Instanzen , sodass keine generischen Parameter auf der rechten Seite der Zuweisung dupliziert werden müssen:

List<String> list = new ArrayList<>();

Eine Liste mit fester Größe kann wie folgt definiert werden:

List<String> list = Arrays.asList("foo", "bar");

Für unveränderliche Listen können Sie die Guava- Bibliothek verwenden:

List<String> list = ImmutableList.of("foo", "bar");
Vitalii Fedorenko
quelle
Ich habe eine Frage zu dieser Deklaration. List <String> list = Arrays.asList ("foo", "bar"); Ich frage mich, ob die Liste in der Erklärung ein Objekt ist.
20

List ist nur eine Schnittstelle wie Set .

Wie HashSet eine Implementierung eines Sets ist, das bestimmte Eigenschaften hinsichtlich der Leistung zum Hinzufügen / Nachschlagen / Entfernen aufweist, ist ArrayList die bloße Implementierung einer Liste.

Wenn Sie sich die Dokumentation zu den jeweiligen Schnittstellen ansehen, finden Sie "Alle bekannten Implementierungsklassen" und können entscheiden, welche für Ihre Anforderungen besser geeignet ist.

Wahrscheinlich ist es ArrayList .

Sorin Mocanu
quelle
18

Listist eine Schnittstelle wie Setund hat ArrayListund LinkedListals Allzweckimplementierungen .

Wir können eine Liste erstellen als:

 List<String> arrayList = new ArrayList<>();
 List<String> linkedList = new LinkedList<>(); 

Wir können auch eine Liste mit fester Größe erstellen als:

List<String> list = Arrays.asList("A", "B", "C");

Wir würden fast immer ArrayListgegen die LinkedListUmsetzung verwenden:

  1. LinkedList verwendet viel Platz für Objekte und funktioniert schlecht, wenn wir viele Elemente haben.
  2. Jede indizierte Operation in LinkedListerfordert O (n) Zeit im Vergleich zu O (1) inArrayList .
  3. Überprüfen Sie diesen Link für weitere Informationen.

Die Liste erstellt von Arrays.asList oben kann nicht strukturell geändert werden, ihre Elemente können jedoch weiterhin geändert werden.

Java 8

Gemäß Dokument gibt die Methode Collections.unmodifiableListeine nicht veränderbare Ansicht der angegebenen Liste zurück. Wir können es bekommen wie:

Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

Java 9

Wenn wir Java 9 verwenden, dann:

List<String> list = List.of("A", "B");

Java 10

Wenn wir uns in Java 10 befinden, gibt die Methode Collectors.unmodifiableListeine in Java 9 eingeführte Instanz einer wirklich nicht veränderbaren Liste zurück. Weitere Informationen zum Unterschied zwischen vs in Java 10 finden Sie in dieser Antwort .Collections.unmodifiableListCollectors.unmodifiableList

akhil_mittal
quelle
9

Manchmal - aber nur sehr selten - möchten Sie möglicherweise anstelle einer neuen ArrayList eine neue LinkedList. Beginnen Sie mit ArrayList. Wenn Sie Leistungsprobleme haben und nachweisen, dass die Liste das Problem ist, und wenn Sie dieser Liste viel hinzufügen und löschen, wechseln Sie - nicht vorher - zu einer LinkedList und prüfen Sie, ob sich die Situation verbessert. Aber im Wesentlichen bleiben Sie bei ArrayList und alles wird gut.

Carl Manaster
quelle
9
List list = new ArrayList();

Oder mit Generika

List<String> list = new ArrayList<String>();

Sie können Zeichenfolgen natürlich auch durch beliebige Variablentypen wie Integer ersetzen.

Paulo Guedes
quelle
7

Ein Beispiel:

List somelist = new ArrayList();

Sie können im Javadoc nach List suchen und alle bekannten Implementierungsklassen der ListSchnittstelle finden, die in der Java-API enthalten sind.

Alex B.
quelle
7

Mit Google Collections können Sie die folgenden Methoden in der Lists- Klasse verwenden

import com.google.common.collect.Lists;

// ...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

Es gibt Überladungen für die Varargs-Initialisierung und -Initialisierung von a Iterable<T> .

Der Vorteil dieser Methoden besteht darin, dass Sie den generischen Parameter nicht explizit wie beim Konstruktor angeben müssen - der Compiler leitet ihn aus dem Typ der Variablen ab.

Ben Lings
quelle
6
List<Object> nameOfList = new ArrayList<Object>();

Sie müssen importieren Listund ArrayList.

jp093121
quelle
6

Mehr Optionen, um dasselbe mit Java 8 zu tun, nicht besser, nicht schlechter, nur anders. Wenn Sie zusätzliche Arbeit mit den Listen leisten möchten, bietet Streams Ihnen mehr Alternativen (Filtern, Zuordnen, Reduzieren usw.).

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));
warum
quelle
6

Mit Java 9 können Sie Folgendes tun, um eine unveränderliche zu erstellen List:

List<Integer> immutableList = List.of(1, 2, 3, 4, 5);

List<Integer> mutableList = new ArrayList<>(immutableList);
Jacob G.
quelle
6

Optional können Sie hier die doppelte Klammerinitialisierung verwenden:

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};
wütend_gopher
quelle
2
Dies ist eine teure Operation. Sie erstellen hier eine anonyme Unterklasse von ArrayList.
Vikram Bodicherla
@ VikramBodicherla Ich stimme zu. Hier geht es mehr um Syntaxzucker.
Angry_Gopher
5

Es gibt viele Möglichkeiten, ein Set und eine Liste zu erstellen. HashSet und ArrayList sind nur zwei Beispiele. Es ist heutzutage auch ziemlich üblich, Generika mit Sammlungen zu verwenden. Ich schlage vor, Sie schauen sich an, was sie sind

Dies ist eine gute Einführung in die integrierten Sammlungen von Java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

Peter Lawrey
quelle
5
List arrList = new ArrayList();

Es ist besser, wenn Sie Generika verwenden, wie unten vorgeschlagen:

List<String> arrList = new ArrayList<String>();

arrList.add("one");

Wenn Sie LinkedList verwenden.

List<String> lnkList = new LinkedList<String>();
Rohit Goyal
quelle
4

Mit Eclipse-Sammlungen können Sie eine Liste wie folgt erstellen:

List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

Wenn Sie eine unveränderliche Liste wollen:

ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

Sie können das automatische Boxen vermeiden, indem Sie primitive Listen verwenden. So erstellen Sie Int-Listen:

MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

Es gibt Varianten für alle 8 Grundelemente.

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen.

Craig P. Motlin
quelle
4

Im Folgenden finden Sie einige Möglichkeiten, wie Sie Listen erstellen können.

  • Dadurch wird eine Liste mit fester Größe erstellt. Das Hinzufügen / Entfernen von Elementen ist nicht möglich. java.lang.UnsupportedOperationExceptionWenn Sie dies versuchen, wird eine Liste ausgelöst .

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});


  • Die folgende Version ist eine einfache Liste, in der Sie eine beliebige Anzahl von Elementen hinzufügen / entfernen können.

    List<String> list = new ArrayList<>();


  • So erstellen Sie ein LinkedListin Java. Wenn Sie häufig Elemente in die Liste einfügen / löschen müssen, sollten Sie LinkedListstattdessen verwendenArrayList

    List<String> linkedList = new LinkedList<>();
JoBⅈN
quelle
1
Sie können verwenden Arrays.asList("Male", "Female").
Johny
3

Versuche dies:

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

Oder:

List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");
Gavriel Cohen
quelle
2

Wenn Sie eine serialisierbare, unveränderliche Liste mit einer einzelnen Entität benötigen, können Sie Folgendes verwenden:

List<String> singList = Collections.singletonList("stackoverlow");
erol yeniaras
quelle
2

Als Deklaration der Array-Liste in Java gilt

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable  

Es gibt zahlreiche Möglichkeiten, Array-Listen in Java zu erstellen und zu initialisieren.

 1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

    List<Integer> immutableList = List.of(1, 2);


 6) Creation and initializing at a time

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();
Mak
quelle