So erstellen Sie eine neue Liste in Java

Wir erstellen ein Setals:

Set myset = new HashSet()

Wie erstellen wir eine Listin Java?

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

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

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

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!

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 .

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

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

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 .

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

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.

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.

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.

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.

List<Object> nameOfList = new ArrayList<Object>();

Sie müssen importieren Listund ArrayList.

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

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

Optional können Sie hier die doppelte Klammerinitialisierung verwenden:

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};

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

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

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.

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

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

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

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