Liste der Listen in Java – Ein vollständiger Leitfaden

A Aufführen ist eine Auftragssammlung, die Elemente jeden Typs speichern kann, einschließlich Duplikaten und Nullwerten. In Java, Eine Liste kann eine andere Liste als ihr Element speichern, was als Liste von Listen, verschachtelte Liste oder 2D-Liste bezeichnet wird. Betrachten Sie als Beispiel die folgende Abbildung, die einige einzelne Listen und eine Liste von Listen (verschachtelte Listen) zeigt:

Aus dieser Abbildung können Sie erkennen, dass jedes Element einer Liste von Listen auch eine Liste ist.

Dieser Artikel enthält eine vollständige Anleitung zu einer Liste von Listen in Java anhand verschiedener Beispiele.

So erstellen/deklarieren Sie eine leere Liste von Listen in Java

Der neu Der Operator ist die bequemste Möglichkeit, eine leere (veränderbare) Liste von Listen in Java zu erstellen. Importieren Sie dazu zunächst die erforderlichen Klassen wie List und ArrayList aus dem Paket „java.util“ und verwenden Sie dann den neuen Operator wie folgt:

import java.util.*;

class ListOfListsExample
{
    public static void main(String() args)
    {
        List<List<String>> exampleLists = new ArrayList<>();
        System.out.println("The Created List: " + exampleLists);
    }
}

In der Hauptmethode erstellen wir zunächst mit dem neuen Operator einen String-Typ „exampleLists“. Anschließend drucken wir die erstellte Liste auf der Konsole aus:

Anschließend können Sie verschiedene Listen Ihrer Wahl erstellen und diese mithilfe der Methode add() zu dieser verschachtelten Liste hinzufügen.

So erstellen/deklarieren Sie eine verschachtelte Liste in Java

Um eine verschachtelte Liste (Liste von Listen) in Java zu erstellen, können Sie „hinzufügen()” Methode, die „Arrays.asList()”-Methode oder die Java 8-Methode „Stream.of()“.

Methode 2: Erstellen Sie eine verschachtelte Liste mit Arrays.asList()

asList() ist eine integrierte Methode der Arrays-Klasse, die eine Liste fester Größe basierend auf dem bereitgestellten Array abruft. Diese Methode erstellt eine unveränderliche Liste von Listen. Sie können sie jedoch mit dem neuen ArrayList-Objekt verwenden, um eine veränderbare Liste zu erstellen. Es ist in der Lage, eine Liste von Listen in einer einzigen Zeile zu erstellen, wie unten gezeigt:

package javaBeat;
import java.util.*;

class ListOfListsExample {
  public static void main(String() args) {
List<List<String>> exampleLists = Arrays.asList(
      Arrays.asList("Joseph","Mike", "John"),
      Arrays.asList("Alex", "Ambrose", "Seth"),
      Arrays.asList("Roman", "Paul"));
       System.out.println("The Create ListOfLists: " + exampleLists);
  }
}

Im obigen Code erstellen wir mithilfe der Methode Arrays.asList() eine Liste von Listen mit dem Namen „exampleLists“. Da jedes Element einer Liste von Listen auch eine Liste ist, verwenden wir die Methode asList() dreimal, um drei Listen als Elemente der Beispiellisten hinzuzufügen. Bei erfolgreicher Ausführung erhalten Sie die folgende Ausgabe auf der Konsole:

Alternativ können Sie verschiedene Listen separat erstellen und dann mit der Methode asList() eine neue Liste von Listen erstellen:

package javaBeat;
import java.util.*;

class ListOfListsExample {
  public static void main(String() args) {
      List<String> empNames = Arrays.asList("Joseph","Mike", "John");
      List<Integer> empAges = Arrays.asList(25, 24, 27);
      List<String> designation = Arrays.asList("Author", "Team Lead", "Manager");
      List<List<? extends Object>> exampleLists = Arrays.asList(empNames, empAges, designation);
      System.out.println("The Create ListOfLists: " + exampleLists);
  }
}

In diesem Code erstellen wir zunächst drei Listen unterschiedlichen Typs. Anschließend wenden wir die Methode asList() an, um aus den bereitgestellten Listen eine Liste mit Listen zu erstellen. Abschließend drucken wir die erstellte Liste der Listen auf der Konsole aus:

Methode 2: Erstellen Sie eine Liste von Listen mit add()

add() ist eine integrierte Methode der List-Schnittstelle, die Elemente zu einer Liste hinzufügt/einfügt. Sie können mit der Methode add() eine Liste von Listen erstellen, indem Sie verschiedene Listen zu einer verschachtelten Liste hinzufügen:

package javaBeat;
import java.util.ArrayList;
import java.util.List;
class ListOfListsExample {
  public static void main(String() args) {
  //creating different lists
  List<String> empNames =  new ArrayList<>();
  List<Integer> empAges = new ArrayList<>();
  List<String> designation = new ArrayList<>();
  List<List<? extends Object>> exampleLists = new ArrayList<>();
 
  //adding elements to lists
  empNames.add("Joseph");
  empNames.add("Mike");
  empNames.add("John");

  empAges.add(25);
  empAges.add(24);
  empAges.add(27);
 
  designation.add("Author");
  designation.add("Team Lead");
  designation.add("Manager");

//Creating a List of Lists
  exampleLists.add(empNames);
  exampleLists.add(empAges);
  exampleLists.add(designation);

  System.out.println("The Created List of Lists: " + exampleLists);
}
}

Zuerst erstellen wir drei einfache Listen und eine verschachtelte Liste mit dem neuen Operator. Danach verwenden wir die Methode add(), um jeder Liste neue Elemente hinzuzufügen bzw. einzufügen. Schließlich verwenden wir die Methode add(), um die angegebenen Listen als Elemente der verschachtelten Liste hinzuzufügen:

Methode 3: Erstellen Sie eine Liste von Listen mit Stream.of()

„Stream.of()“ ist eine der Java 8-Stream-API-Methoden, die mit der Collect()-Methode zum Erstellen einer Liste von Listen verwendet werden kann. Lassen Sie uns lernen, wie es mit dem folgenden Codeblock geht:

package javaBeat;
import java.util.*;
import java.util.stream.*;

class ListOfListsExample {
  public static void main(String() args) {
// creating different lists
List<String> empNames = new ArrayList<>();
List<Integer> empAges = new ArrayList<>();
List<String> designation = new ArrayList<>();
// adding elements to lists
empNames.add("Joseph");
empNames.add("Mike");
empNames.add("John");
empAges.add(25);
empAges.add(24);
empAges.add(27);
designation.add("Author");
designation.add("Team Lead");
designation.add("Manager");
// Creating a List of Lists from the given lists
List<List<? extends Object>> exampleLists = Stream.of(empNames, empAges, designation).collect(Collectors.toList());
System.out.println("The Created List of Lists: " + exampleLists);
}
}

Im obigen Code importieren wir zunächst die erforderlichen Klassen aus dem Paket „java.util“ und der Java 8-Stream-Funktionalität. Anschließend haben wir drei verschiedene Listen erstellt und ihnen Elemente hinzugefügt. Schließlich verwenden wir die Methode „Stream.of()“, um einen Stream bereitgestellter Listen zu erstellen, und die Methode „collect(Collectors.toList())“, um sie in einer Liste zu sammeln:

Wie iteriere ich eine verschachtelte Liste in Java?

Um eine Liste von Listen in Java zu iterieren, können Sie die verschachtelte for-each-Schleife oder die forEach()-Methode verwenden. Wir werden die Funktionsweise jeder Methode anhand von Beispielen demonstrieren.

  • Iterieren Sie eine Liste von Listen mithilfe einer verschachtelten For-Eached-Schleife
  • Die verschachtelte erweiterte for-Schleife oder for-each-Schleife ist die einfachste Möglichkeit, eine Liste von Listen zu iterieren. Die äußere for-Schleife durchläuft jede Liste, während die innere for-Schleife jedes Element der inneren Liste durchläuft:

    System.out.println("The Nested List: ");
      for(List list : exampleLists)
            {
            for(Object i : list)
              {
                System.out.print( i+ ", ");
              }  }
    

    Im obigen Code verwenden wir eine verschachtelte erweiterte for-Schleife, um eine bereits erstellte Liste von Listen mit dem Namen exampleLists zu durchlaufen. Die print()-Methode wird innerhalb der inneren Schleife verwendet, um jedes Element der verschachtelten Liste von Listen zu drucken:

  • Iterieren Sie eine Liste von Listen mit forEach()
  • Sie können die Java 8-Methode forEach() verwenden, um die Elemente einer Liste von Listen zu durchlaufen. Dies ist eine prägnante und bequeme Möglichkeit, eine Java-Liste von Listen zu iterieren:

    System.out.println("The Nested List: ");
      exampleLists.forEach((list) -> {
        list.forEach((listelement) -> System.out.print(listelement + ", "));
      });
    }
    

    Wie greife ich in Java auf eine innere Liste zu?

    Mit der Methode get() können Sie auf jede bestimmte innere Liste einer verschachtelten Liste zugreifen. Geben Sie dazu den Index der inneren Liste als Parameter der get()-Methode an. Der folgende Code greift beispielsweise auf eine innere Liste zu, deren Index 2 ist (dritte innere Liste):

    System.out.println(exampleLists.get(2));
    

    Wie greife ich in Java auf Elemente einer inneren Liste zu?

    Um auf ein bestimmtes Element einer inneren Liste zuzugreifen, müssen Sie die Methode get() mehrmals verwenden. Die erste get()-Methode greift auf eine bestimmte innere Liste zu, und die zweite get()-Methode greift auf ein bestimmtes Element dieser bestimmten Liste zu. Der folgende Code greift beispielsweise mit der Methode get() auf das zweite Element der dritten inneren Liste zu:

    System.out.println(exampleLists.get(2).get(1));
    

    Wie aktualisiere oder ändere ich eine äußere Liste in Java?

    Sie können eine veränderbare äußere Liste entsprechend Ihren Anforderungen ändern. Um beispielsweise ein bestimmtes Listenelement zu entfernen/eliminieren, können Sie die Methode „remove()“ mit dem gewünschten Index verwenden. Der folgende Code entfernt das dritte Element der exampleLists:

    System.out.println("Removed Element: " + exampleLists.remove(2));
    System.out.println("Modified List of Lists: " + exampleLists);
    

    Ebenso können Sie andere List-Methoden verwenden, um eine verschachtelte Liste zu ändern, z. B. add(), addAll(), removeAll() usw.

    Wie aktualisiere oder ändere ich eine innere Liste in Java?

    Um eine innere Liste zu aktualisieren, müssen Sie zunächst mit der get()-Methode auf diese bestimmte Liste zugreifen und können dann eine Listenmethode verwenden, um die gewünschte Funktionalität auszuführen.

    Im folgenden Code entfernt „exampleLists.get(2).remove(2)“ das dritte Element der dritten Liste:

    System.out.println("Removed Element: " + exampleLists.get(2).remove(2));
    System.out.println("Modified List of Lists: " + exampleLists);
    

    Wie finde ich die Länge einer Liste von Listen in Java?

    Um die Länge einer verschachtelten Liste zu ermitteln, können Sie einfach die Methode size() mit Punktsyntax verwenden:

    System.out.println("Size of Nested List: " + exampleLists.size());
    

    Wenn Sie alle Elemente der verschachtelten Listen berechnen möchten, verwenden Sie die verschachtelte for-each-Schleife und erhöhen Sie den Zähler bei jeder Iteration:

    int count =0;
    for(List list : exampleLists)
        {
        for(Object i : list)
          {
          count++;
          }
      }System.out.println("Total Elements in a List: " + count);
    

    Wie importiere ich eine CSV-Datei in eine Liste von Listen in Java?

    Ein häufiger Anwendungsfall verschachtelter Listen ist das Importieren des Inhalts einer CSV-Datei in eine Liste von Listen. Importieren Sie dazu die notwendigen Klassen aus den Paketen „java.io“ und „java.util“:

    package javaBeat;
    import java.io.*;
    import java.util.*;
    class ListOfListsExample {    public static void main(String() args) {
    String readFile = "greetings.txt";
    String readLine;
    List<List<String>> readCSV = new ArrayList<>();
    try (BufferedReader br = new BufferedReader(new FileReader(readFile)))
      {
        while((readLine = br.readLine()) != null)
                {  
                String() val = readLine.split(",");
                readCSV.add(Arrays.asList(val));
                }
        }
        catch (IOException excep)
          {
    System.out.println(excep);
          }
    for (List<String> lineByLine : readCSV)
    {
    System.out.println(lineByLine);
    }
    }
    }
    

    Im obigen Code:

    • Zuerst erstellen wir eine Variable vom Typ String und initialisieren sie mit einer Datei, die wir lesen möchten.
    • Als nächstes erstellen wir eine verschachtelte Liste vom Typ String, in der wir den Inhalt der ausgewählten CSV-Datei speichern.
    • Im try-Block verwenden wir die Klasse BufferedReader, um den Inhalt der ausgewählten CSV-Datei zu lesen.
    • Innerhalb des try-Blocks verwenden wir eine Schleife mit der Methode readLine(), um die Daten/Inhalte der Datei Zeile für Zeile auszulesen. Dieser Vorgang wird fortgesetzt, bis die Datei den Inhalt enthält.
    • In der while-Schleife verwenden wir die Methode split(), um den Dateiinhalt von einem „“ zu trennen und ihn in einem String-Array „val“ zu speichern. In der nächsten Zeile wird add() zusammen mit der asList()-Methode verwendet, um diese Daten Zeile für Zeile in eine verschachtelte Liste „readCSV“ einzufügen.
    • Der Catch-Block fängt die möglichen E/A-Ausnahmen ab und gibt sie auf der Konsole aus.
    • Schließlich wird eine erweiterte for-Schleife verwendet, um den Inhalt der verschachtelten Liste zu durchlaufen und auszugeben.

    Auf diese Weise können Sie eine CSV-Datei in eine Liste von Listen vom Typ String in Java importieren.

    Wie glätte ich eine 2-D-Liste (verschachtelt) in Java?

    Sie können verschiedene Methoden wie flatMap(), Reduce(), Guava Library usw. verwenden, um eine verschachtelte Liste (Listen) in Java zu reduzieren. Um die praktische Umsetzung dieser Methoden zu erfahren, können Sie unseren speziellen Leitfaden zum Thema „So reduzieren Sie eine Liste von Listen in Java“.

    Abschließende Gedanken

    Eine Liste, die einige andere Listen als Elemente enthält, wird als Liste von Listen, verschachtelte Liste oder 2D-Liste bezeichnet. Verschachtelte Listen sind in verschiedenen Anwendungsfällen nützlich, z. B. um den Inhalt einer CSV-Datei in eine Liste von Listen zu importieren, um mehrere Sätze zusammengehöriger Daten in einer einzigen Liste zu speichern usw.

    In Java können Benutzer über Methoden wie eine Liste mit Listen erstellen Arrays.asList(), hinzufügen()oder Stream.of(). Sobald eine Liste mit Listen erstellt wurde, können Sie diese mit der for every-Schleife oder der forEach()-Methode iterieren. Außerdem können Sie eine veränderbare Liste von Listen nach Ihren Wünschen ändern. Beispielsweise können Sie einer verschachtelten Liste neue/unerwünschte Elemente hinzufügen bzw. daraus entfernen.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen