Menü

Java-Liste - Erstellen, Initialisieren und Verwenden einer Liste in Java

  • Haupt
  • Andere
  • Java-Liste - Erstellen, Initialisieren und Verwenden einer Liste in Java

java list how create

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

In diesem Java-Listen-Tutorial wird erläutert, wie Sie Listen in Java erstellen, initialisieren und drucken. Das Tutorial erklärt auch die Liste der Listen mit vollständigem Codebeispiel:

Dieses Tutorial führt Sie in die Datenstrukturliste ein, die eine der Grundstrukturen in der Java Collection-Oberfläche darstellt.

Eine Liste in Java ist eine Folge von Elementen gemäß einer Reihenfolge. Die List-Schnittstelle des Pakets java.util implementiert diese Folge von Objekten, die in einer bestimmten Weise angeordnet sind, die als List bezeichnet wird.

=> Überprüfen Sie ALLE Java-Tutorials hier.

Listen in der Java-Einführung

Genau wie bei Arrays kann auf die Listenelemente auch über Indizes zugegriffen werden, wobei der erste Index bei 0 beginnt. Der Index gibt ein bestimmtes Element am Index 'i' an, d. H. Es sind i-Elemente vom Anfang der Liste entfernt.

Einige der Merkmale der Liste in Java sind:

  • Listen können doppelte Elemente enthalten.
  • Die Liste kann auch Nullelemente enthalten.
  • Listen unterstützen Generika, d. H. Sie können generische Listen haben.
  • Sie können auch gemischte Objekte (Objekte verschiedener Klassen) in derselben Liste haben.
  • Listen behalten immer die Einfügereihenfolge bei und ermöglichen den Positionszugriff.

Was du lernen wirst:

Liste in Java

Die Java List-Schnittstelle ist ein Untertyp der Java Collection-Schnittstelle. Dies ist die Standardschnittstelle, die die Collection-Schnittstelle von Java erbt.

Im Folgenden finden Sie ein Klassendiagramm der Java List-Schnittstelle.

Java List Class Diagram
Java List Class Diagram

Wie im obigen Klassendiagramm gezeigt, erstreckt sich die Java-Listenschnittstelle von der Collection-Schnittstelle des Pakets java.util, die sich wiederum von der Iterable-Schnittstelle des Pakets java.util erstreckt. Die Klasse AbstractList stellt die Skelettimplementierung der List-Schnittstelle bereit.

Die Klassen LinkedList, Stack, Vector, ArrayList und CopyOnWriteArrayList sind alle Implementierungsklassen der List-Schnittstelle, die häufig von Programmierern verwendet werden. Daher gibt es in Java vier Arten von Listen, d. H. Stack, LinkedList, ArrayList und Vector.

Wenn Sie die Listenschnittstelle implementieren müssen, können Sie daher abhängig von den Anforderungen eine der oben genannten Listentypklassen implementieren. Um die Funktionalität der Listenschnittstelle in Ihr Programm aufzunehmen, müssen Sie Importieren Sie das Paket java.util. *, das die Listenschnittstelle und andere Klassendefinitionen wie folgt enthält:

import java.util.*;

Liste erstellen und deklarieren

Wir haben bereits festgestellt, dass List eine Schnittstelle ist und von Klassen wie ArrayList, Stack, Vector und LinkedList implementiert wird. Daher können Sie Deklarieren und erstellen Sie Instanzen der Liste auf eine der folgenden Arten:

List linkedlist = new LinkedList(); List arrayList = new ArrayList(); List vec_list = new Vector(); List stck_list = new Stack();

Wie oben gezeigt, können Sie eine Liste mit einer der oben genannten Klassen erstellen und diese Listen dann mit Werten initialisieren. Anhand der obigen Anweisungen können Sie erkennen, dass sich die Reihenfolge der Elemente in Abhängigkeit von der Klasse ändert, die zum Erstellen einer Instanz der Liste verwendet wird.

Zum Beispiel, Für eine Liste mit Stapelklasse lautet die Reihenfolge Last In, First Out (LIFO).

Java-Liste initialisieren

Sie können eine der unten angegebenen Methoden verwenden, um ein Listenobjekt zu initialisieren.

# 1) Verwenden der asList-Methode

Die Methode asList () wird bereits im Thema Arrays ausführlich behandelt. Mit den Array-Werten können Sie eine unveränderliche Liste erstellen.

Die allgemeine Syntax lautet:

List listname = Arrays.asList(array_name);

Hier sollte der Datentyp mit dem des Arrays übereinstimmen.

Die obige Anweisung erstellt eine unveränderliche Liste. Wenn Sie möchten, dass die Liste veränderbar ist, müssen Sie eine Instanz der Liste mit new erstellen und ihr dann die Array-Elemente mit der asList-Methode zuweisen.

Dies ist wie folgt:

List listname = new ArrayList (Arrays.asList(array_name));

Lasst uns Implementieren Sie ein Programm in Java, das die Erstellung und Initialisierung der Liste mithilfe der asList-Methode zeigt .

wie man swf dateien auf dem pc öffnet
import java.util.*; public class Main { public static void main(String() args) { //array of strings String() strArray = {'Delhi', 'Mumbai', 'Kolkata', 'Chennai'}; //initialize an immutable list from array using asList method List mylist = Arrays.asList(strArray); //print the list System.out.println('Immutable list:'); for(String val : mylist){ System.out.print(val + ' '); } System.out.println(' '); //initialize a mutable list(arraylist) from array using asList method List arrayList = new ArrayList(Arrays.asList(strArray)); System.out.println('Mutable list:'); //add one more element to list arrayList.add('Pune'); //print the arraylist for(String val : arrayList){ System.out.print(val + ' '); } }

Ausgabe:

Ausgabe der Liste mit der Methode asList

Im obigen Programm haben wir die unveränderliche Liste zuerst mit der asList-Methode erstellt. Anschließend erstellen wir eine veränderbare Liste, indem wir eine Instanz von ArrayList erstellen und diese ArrayList dann mit Werten aus dem Array mithilfe der asList-Methode initialisieren.

Da die zweite Liste veränderbar ist, können wir ihr auch weitere Werte hinzufügen.

# 2) Verwenden von List.add ()

Wie bereits erwähnt, kann die Liste, da sie nur eine Schnittstelle ist, nicht instanziiert werden. Wir können jedoch Klassen instanziieren, die diese Schnittstelle implementieren. Um die Listenklassen zu initialisieren, können Sie daher ihre jeweiligen Add-Methoden verwenden. Dies ist eine Listenschnittstellenmethode, die jedoch von jeder der Klassen implementiert wird.

Wenn du Instanziieren Sie eine verknüpfte Listenklasse wie folgt:

List llist = new LinkedList ();

Um dann ein Element zu einer Liste hinzuzufügen, können Sie die Methode add wie folgt verwenden:

llist.add(3);

Es gibt auch eine Technik namens 'Double Brace Initialization', bei der die Liste durch Aufrufen der add-Methode in derselben Anweisung instanziiert und initialisiert wird.

Dies geschieht wie folgt:

List llist = new LinkedList (){{ add(1); add(3);}};

Die obige Anweisung fügt die Elemente 1 und 3 zur Liste hinzu.

Das folgende Programm zeigt die Initialisierungen der Liste mit der Methode add . Es wird auch die Doppelklammer-Initialisierungstechnik verwendet.

import java.util.*; public class Main { public static void main(String args()) { // ArrayList.add method List str_list = new ArrayList(); str_list.add('Java'); str_list.add('C++'); System.out.println('ArrayList : ' + str_list.toString()); // LinkedList.add method List even_list = new LinkedList(); even_list.add(2); even_list.add(4); System.out.println('LinkedList : ' + even_list.toString()); // double brace initialization - use add with declaration & initialization List num_stack = new Stack(){{ add(10);add(20); }}; System.out.println('Stack : ' + num_stack.toString()); } }

Ausgabe:

Initialisierungen der Liste mit der Methode add

Dieses Programm verfügt über drei verschiedene Listendeklarationen, d. H. ArrayList, LinkedList und Stack.

ArrayList- und LinkedList-Objekte werden instanziiert, und dann werden die add-Methoden aufgerufen, um diesen Objekten Elemente hinzuzufügen. Für den Stapel wird eine doppelte Klammerinitialisierung verwendet, bei der die Add-Methode während der Instanziierung selbst aufgerufen wird.

# 3) Verwenden von Sammlungsklassenmethoden

Die Sammlungsklasse von Java verfügt über verschiedene Methoden, mit denen die Liste initialisiert werden kann.

Einige der Methoden sind:

  • füge alle Hinzu

Das Die allgemeine Syntax für die addAll-Methode für Sammlungen lautet:

List listname = Collections.EMPTY_LIST; Collections.addAll(listname = new ArrayList(), values…);

Hier fügen Sie einer leeren Liste Werte hinzu. Die Methode addAll verwendet die Liste als ersten Parameter, gefolgt von den Werten, die in die Liste eingefügt werden sollen.

  • unmodifizierbare Liste ()

Die Methode 'unmodizableList ()' gibt eine unveränderliche Liste zurück, zu der die Elemente weder hinzugefügt noch gelöscht werden können.

Die allgemeine Syntax dieser Methode lautet wie folgt:

List listname = Collections.unmodifiableList(Arrays.asList(values…));

Die Methode verwendet Listenwerte als Parameter und gibt eine Liste zurück. Wenn Sie überhaupt versuchen, ein Element zu dieser Liste hinzuzufügen oder daraus zu löschen, löst der Compiler eine Ausnahme aus UnsupportedOperationException.

  • singletonList ()

Die Methode 'singletonList' gibt eine Liste mit einem einzelnen Element zurück. Die Liste ist unveränderlich.

Die allgemeine Syntax für diese Methode lautet:

List listname = Collections.singletonList(value);

Das folgende Java-Programm demonstriert alle drei Methoden der Collections-Klasse oben diskutiert.

import java.util.*; public class Main { public static void main(String args()) { // empty list List list = new ArrayList(); // Instantiating list using Collections.addAll() Collections.addAll(list, 10, 20, 30, 40); // Print the list System.out.println('List with addAll() : ' + list.toString()); // Create& initialize the list using unmodifiableList method List intlist = Collections.unmodifiableList( Arrays.asList(1,3,5,7)); // Print the list System.out.println('List with unmodifiableList(): ' + intlist.toString()); // Create& initialize the list using singletonList method List strlist = Collections.singletonList('Java'); // Print the list System.out.println('List with singletonList(): ' + strlist.toString()); } }

Ausgabe:

Drei Methoden der Collections-Klasse

# 4) Verwenden von Java8-Streams

Mit der Einführung von Streams in Java 8 können Sie auch einen Datenstrom erstellen und in einer Liste sammeln.

Folgende Programm zeigt die Erstellung einer Liste mit Stream.

import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; public class Main { public static void main(String args()) { // Creating a List using toList Collectors method List list1 = Stream.of('January', 'February', 'March', 'April', 'May') .collect(Collectors.toList()); // Print the list System.out.println('List from Java 8 stream: ' + list1.toString()); } }

Ausgabe:

Erstellung einer Liste mit Stream

Das obige Programm sammelt den String-Stream in einer Liste und gibt ihn zurück. Sie können neben asList auch die anderen Collectors-Methoden wie 'toCollection', 'unmodizableList' usw. in der Collect-Funktion verwenden.

# 5) Java 9 List.of () -Methode

In Java 9, List.of (), wird eine neue Methode eingeführt, die eine beliebige Anzahl von Elementen verwendet und eine Liste erstellt. Die erstellte Liste ist unveränderlich.

import java.util.List; public class Main { public static void main(String args()) { // Create a list using List.of() List strList = List.of('Delhi', 'Mumbai', 'Kolkata'); // Print the List System.out.println('List using Java 9 List.of() : ' + strList.toString()); } }

Ausgabe:

Java 9 List.of () -Methode

Listenbeispiel

Im Folgenden finden Sie ein vollständiges Beispiel für die Verwendung einer Listenschnittstelle und ihrer verschiedenen Methoden.

import java.util.*; public class Main { public static void main(String() args) { // Creating a list List intList = new ArrayList(); //add two values to the list intList.add(0, 10); intList.add(1, 20); System.out.println('The initial List: ' + intList); // Creating another list List cp_list = new ArrayList(); cp_list.add(30); cp_list.add(40); cp_list.add(50); // add list cp_list to intList from index 2 intList.addAll(2, cp_list); System.out.println('List after adding another list at index 2: '+ intList); // Removes element from index 0 intList.remove(0); System.out.println('List after removing element at index 0: ' + intList); // Replace value of last element intList.set(3, 60); System.out.println('List after replacing the value of last element: ' + intList); } }

Ausgabe:

Ausgabe des Listenbeispiels

Die obige Programmausgabe zeigt die verschiedenen Operationen, die an einer ArrayList ausgeführt werden. Zunächst wird die Liste erstellt und initialisiert. Anschließend wird der Inhalt einer anderen Liste in diese Liste kopiert und ein Element aus der Liste entfernt. Schließlich wird das letzte Element in der Liste durch einen anderen Wert ersetzt.

Wir werden die Listenmethoden in unserem nächsten Tutorial detailliert untersuchen.

Liste drucken

Es gibt verschiedene Methoden, mit denen Sie die Elemente der Liste in Java drucken können.

Lassen Sie uns hier einige der Methoden diskutieren.

# 1) Verwenden von For Loop / Enhanced For Loop

Die Liste ist eine geordnete Sammlung, auf die über Indizes zugegriffen werden kann. Sie können eine for-Schleife verwenden, die zum Iterieren verwendet wird, indem die Indizes zum Drucken jedes Elements der Liste verwendet werden.

Java verfügt über eine andere Version der for-Schleife, die als erweiterte for-Schleife bezeichnet wird und auch zum Zugreifen auf und Drucken auf jedes Element der Liste verwendet werden kann.

Das unten gezeigte Java-Programm demonstriert das Drucken von Listeninhalten mit for-Schleife und erweitert für for-Schleife.

import java.util.List; import java.util.ArrayList; import java.util.Arrays; class Main{ public static void main (String() args) { //string list List list = Arrays.asList('Java', 'Python', 'C++', 'C', 'Ruby'); //print list using for loop System.out.println('List contents using for loop:'); for (int i = 0; i

Ausgabe:

Drucken von Listeninhalten mit for-Schleife und erweitert für for-Schleife

# 2) Verwenden der toString-Methode

Die Methode 'toString ()' der Listenschnittstelle gibt die Zeichenfolgendarstellung der Liste zurück.

Das Programm unten demonstriert die Verwendung der toString () -Methode.

c ++ Zeichen in Zeichenfolge konvertieren
import java.util.List; import java.util.ArrayList; class Main{ public static void main (String() args){ //initialize a string list List list = new ArrayList(){{add('Python');add('C++');add('Java');}}; // string representation of list using toString method System.out.println('List contents using toString() method:' + list.toString()); } }

Ausgabe:

Verwendung der toString () -Methode

Liste in ein Array konvertiert

Die Liste verfügt über eine Methode toArray (), die die Liste in ein Array konvertiert. Nach der Konvertierung in ein Array können Sie die im jeweiligen Thema beschriebenen Array-Methoden verwenden, um den Inhalt dieses Arrays zu drucken. Sie können entweder die for-Schleife oder sogar die toString-Methode verwenden oder erweitern.

Das folgende Beispiel verwendet die toString-Methode, um den Array-Inhalt zu drucken.

import java.util.*; class Main { public static void main (String() args) { //list of odd numbers List oddlist = Arrays.asList(1,3,5,7,9,11); // using List.toArray() method System.out.println('Contents of list converted to Array:'); System.out.println(Arrays.toString(oddlist.toArray())); } }

Ausgabe:

Liste in ein Array konvertiert

Verwenden von Java 8-Streams

Streams werden in Java 8 eingeführt. Sie können Streams verwenden, um die Liste zu durchlaufen. Es gibt auch Lambdas, mit denen Sie die Liste durchlaufen können.

Das folgende Programm zeigt die Verwendung von Streams, um die Liste zu durchlaufen und ihren Inhalt anzuzeigen.

import java.util.*; class Main{ public static void main (String() args){ //list of even numbers List evenlist = Arrays.asList(2,4,6,8,10,12,14); // print list using streams System.out.println('Contents of evenlist using streams:'); evenlist.stream().forEach(S ->System.out.print(S + ' ')); } }

Ausgabe:

Verwendung von Streams zum Durchlaufen der Liste

Abgesehen von den oben beschriebenen Methoden können Sie Listeniteratoren verwenden, um die Liste zu durchlaufen und ihren Inhalt anzuzeigen. In den folgenden Tutorials finden Sie einen vollständigen Artikel zum Listeniterator.

Liste der Listen

Die Java-Listenschnittstelle unterstützt die Liste der Listen. Dabei sind die einzelnen Elemente der Liste wieder eine Liste. Dies bedeutet, dass Sie eine Liste in einer anderen Liste haben können.

Dieses Konzept ist sehr nützlich, wenn Sie Daten aus beispielsweise CSV-Dateien lesen müssen. Hier müssen Sie möglicherweise mehrere Listen oder Listen in Listen lesen und diese dann im Speicher speichern. Auch hier müssen Sie diese Daten verarbeiten und in die Datei zurückschreiben. In solchen Situationen können Sie daher eine Liste von Listen führen, um die Datenverarbeitung zu vereinfachen.

Das folgende Java-Programm zeigt ein Beispiel für eine Java-Liste von Listen.

In diesem Programm haben wir eine Liste von Listen vom Typ String. Wir erstellen zwei separate Listen vom Typ string und weisen diesen Listen Werte zu. Beide Listen werden mit der Methode add zur Liste der Listen hinzugefügt.

Um den Inhalt der Listenliste anzuzeigen, verwenden wir zwei Schleifen. Die äußere Schleife (foreach) durchläuft die Listen der Listen, die auf die Listen zugreifen. Die innere foreach-Schleife greift auf die einzelnen Zeichenfolgenelemente jeder dieser Listen zu.

import java.util.ArrayList; import java.util.List; public class Main { public static void main(String() args) { //create list of lists List java_listOfLists = new ArrayList (); //create a language list and add elements to it ArrayList lang_list = new ArrayList(); lang_list.add('Java'); lang_list.add('C++'); //add language list to java list of list java_listOfLists.add(lang_list); //create a city list and add elements to it ArrayList city_list = new ArrayList(); city_list.add('Pune'); city_list.add('Mumbai'); //add the city list to java list of lists java_listOfLists.add(city_list); //display the contents of list of lists System.out.println('Java list of lists contents:'); java_listOfLists.forEach((list) -> //access each list { list.forEach((city)->System.out.print(city + ' ')); //each element of inner list }); } }

Ausgabe:

Beispiel einer Java-Liste von Listen

Die Liste der Java-Listen ist ein kleines Konzept, aber besonders wichtig, wenn Sie komplexe Daten in Ihrem Programm lesen müssen.

Häufig gestellte Fragen

F # 1) Was ist eine Liste und ein Set in Java?

Antworten: Eine Liste ist eine geordnete Sammlung von Elementen. Sie können doppelte Elemente in der Liste haben.

Ein Set ist keine bestellte Sammlung. Die Elemente im Set sind nicht in einer bestimmten Reihenfolge angeordnet. Außerdem müssen die Elemente im Set eindeutig sein. Duplikate sind nicht zulässig.

F # 2) Wie funktioniert eine Liste in Java?

Antworten: Die Liste ist eine Schnittstelle in Java, die sich von der Collection-Schnittstelle aus erstreckt. Die Klassen ArrayList, LinkedList, Stack und Vector implementieren die Listenschnittstelle. Somit kann ein Programmierer diese Klassen verwenden, um die Funktionalität der Listenschnittstelle zu nutzen.

F # 3) Was ist eine ArrayList in Java?

Antworten: ArrayList ist ein dynamisches Array. Es ist eine veränderbare Sammlung von Elementen und implementiert die Listenschnittstelle. ArrayList verwendet intern ein Array zum Speichern der Elemente.

F # 4) Beginnen Listen in Java bei 0 oder 1?

Antworten: Listen in Java haben einen auf Null basierenden Ganzzahlindex. Dies bedeutet, dass sich das erste Element in der Liste auf Index 0 befindet, das zweite Element auf Index 1 usw.

F # 5) Ist die Liste bestellt?

Antworten: Ja. Die Liste ist eine geordnete Sammlung von Elementen. Diese Reihenfolge bleibt beim Einfügen eines neuen Elements in die Liste erhalten.

Fazit

Dieses Tutorial gab eine Einführung in die Listenoberfläche in Java. Wir haben auch die wichtigsten Konzepte von Listen wie das Erstellen, Initialisieren von Listen, Drucken von Listen usw. erörtert.

In unseren nächsten Tutorials werden wir die verschiedenen Methoden diskutieren, die von der Listenschnittstelle bereitgestellt werden. Wir werden auch das Iteratorkonstrukt diskutieren, das zum Iterieren des Listenobjekts verwendet wird. Wir werden die Konvertierung von Listenobjekten in andere Datenstrukturen in unserem nächsten Tutorial diskutieren.

=> Besuchen Sie hier, um die Java-Schulungsreihe für alle zu sehen.

Literatur-Empfehlungen

^