Java List: Wichtige Methoden und Einsatzgebiete

Eine Java List ist besonders geeignet für Szenarien, in denen die Größe der Datenmenge nicht im Voraus bekannt ist oder sich im Laufe der Zeit ändern kann. Wir zeigen Ihnen konkrete Beispiele für den Gebrauch von Listen und welche Operationen Sie mit ihnen durchführen können.

Wofür werden Java-Listen verwendet?

Listen sind eine der grundlegenden Datenstrukturen in der Java-Programmierung und haben eine breite Anwendungspalette. Sie beinhalten Elemente in einer geordneten Reihenfolge, die hinzugefügt, geändert, gelöscht oder abgefragt werden können. Die Objekte in einer Java List dürfen verschiedenen Klassen angehören. Zudem ist es möglich, doppelte oder Null-Elemente zu speichern. Außerdem unterstützen Java-Listen generische Klassen und Methoden, was die Typensicherheit gewährleistet.

Einsatzgebiete von Listen sind z. B. Datenbankanwendungen, in denen sie dazu dienen, große Datensätze aus Datenbankabfragen aufzubewahren und auf sie zuzugreifen. In grafischen Benutzeroberflächen werden Java-Listen oft verwendet, um eine Liste von Elementen anzuzeigen, z. B. die Optionen in einem Drop-down-Menü oder die verschiedenen Artikel in einem Onlineshop.

Auch in Algorithmen und Datenstrukturen ist Java List unverzichtbar. Sie wird bei der Implementierung von Sortieralgorithmen, Suchalgorithmen oder Stapel- und Warteschlangenstrukturen eingesetzt. In Netzwerkanwendungen können Listen dazu beitragen, die Verwaltung von Verbindungen und Sockets zu erleichtern.

Die Methoden der Java List

Java List gehört zur Collections-Schnittstelle und muss aus dem Paket java.util importiert werden. Zu den Implementierungsklassen gehören u. a. die Java ArrayList, LinkedList, Vector und Stack. Sie können die verschiedenen Instanzen der Liste folgendermaßen deklarieren:

List linkedList = new LinkedList(); // LinkedList
List arrayList = new ArrayList(); // ArrayList
List vecList = new Vector(); // Vector
List stackList = new Stack(); //Stack

Hier sind einige der wichtigsten Methoden, die in Verbindung mit Java-Listen verwendet werden:

1. `int size(): Bestimmt die Anzahl der Elemente in einer Liste.
2. void add(int index, E element): Fügt ein Element an einer bestimmten Position hinzu.
3. boolean isEmpty(): Prüft, ob die Liste leer ist.
4. void clear(): Entfernt alle Elemente aus der Liste.
5. boolean contains(Object o): Liefert den Wert true, wenn das Objekt o enthalten ist.
6. boolean add(E e): Fügt das angegebene Element am Ende der Liste hinzu.
7. boolean remove(Object o): Entfernt das erste Vorkommen eines bestimmten Elements.
8. E get(int index): Gibt das Element am genannten Index wieder.
9. E set(int index, E element): Ersetzt oder fügt ein Element am jeweiligen Index ein.
10. Object[] toArray(): Liefert einen Array mit den Elementen aus der Liste zurück.
11. List<E> subList(int fromIndex, int toIndex): Erfasst alle Elemente des definierten Intervalls.
12. default void replaceAll(UnaryOperator<E> operator): Standardmethode in Java 8, die auf jedes Element unäre Java-Operatoren anwendet und das Ergebnis mit dem jeweiligen Element ersetzt.

Typische Anwendungsfälle von Java-Listen

Im Folgenden demonstrieren wir Ihnen die häufigsten Anwendungen einer Java List. Dazu gehören Konvertierungen von Arrays in Listen und umgekehrt sowie das Sortieren, Abrufen oder Ändern von Elementen.

Ein Array in eine Liste konvertieren

Zum Konvertieren in einen Array können Sie mit Schleifen eine Liste durchlaufen und durch die Methode .add() die Elemente der Reihe nach dem Array hinzufügen.

    import java.util.*;
    public class ArrayToList{
      public static void main(String args[]){
      // Creating Array
      String[] colors={"blue","green","red","yellow"};
      System.out.println("Array: "+Arrays.toString(colors));
      //Converting Array to List
      List<String> list=new ArrayList<String>();
      for(String color: colors){
        list.add(color);
      }
      System.out.println("List: "+list);
      }
    }

Dies führt zur Ausgabe:

Array: [blue, green, red, yellow]
List: [blue, green, red, yellow]

Eine Liste in einen Array konvertieren

Eine Liste kann mit der Methode toArray() in einen Array umgewandelt werden:

    import java.util.*;
    public class ListToArray{
      public static void main(String args[]){
       List<String> days = new ArrayList<String>();
       days.add("Monday");
       days.add("Tuesday");
       days.add("Wednesday");
       days.add("Thursday");
       days.add("Friday");
       days.add("Saturday");
       days.add("Sunday");
       // Converting ArrayList to Array
       String[] array = days.toArray(new String[days.size()]);
       System.out.println("Array: "+Arrays.toString(array));
       System.out.println("List: "+days);
      }
    }

In der Ausgabe sehen wir, dass die Inhalte des Arrays und der Liste identisch sind:

Array: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
List: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]

Elemente in einer Java List abrufen und ändern

Mit der Methode get() können Sie auf ein Element an einem bestimmten Index zugreifen, während mit set() ein Objekt an einer gewünschten Position ausgetauscht und hinzugefügt werden kann.

    import java.util.*;
    public class ListExample{
      public static void main(String args[]){
      // Creating a List
      List<String> letters=new ArrayList<String>();
      // Adding elements
      letters.add("a");
      letters.add("b");
      letters.add("c");
      // get()
      System.out.println("Element at index 1: "+letters.get(1));
      // set()
      letters.set(2, "d");
      for(String letter: letters)
      System.out.println(letter);
      }
    }

Da in Java die Zählung ab dem Index 0 beginnt, erhalten wir folgendes Ergebnis:

Element at index 1: b
a
b
d

Eine Liste sortieren

Für das Sortieren einer Java List können wir die Methode .sort() der Collections-Klasse benutzen. Wir iterieren mithilfe einer Schleife durch die Liste und geben die Elemente der Reihe nach an die Konsole aus:

    import java.util.*;
    class SortArrayList{
      public static void main(String args[]){
      // Creating a list of numbers
      List<Integer> numbers=new ArrayList<Integer>();
      numbers.add(4);
      numbers.add(57);
      numbers.add(92);
      numbers.add(26);
      // Sorting
      Collections.sort(numbers);
      for(Integer number: numbers)
        System.out.println(number);
      }
    }

Die Zahlen der Java List werden aufsteigend sortiert auf dem Bildschirm angezeigt:

4
26
57
92