Java List: Wichtige Methoden und Ein­satz­ge­bie­te

Eine Java List ist besonders geeignet für Szenarien, in denen die Größe der Da­ten­men­ge 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 Ope­ra­tio­nen Sie mit ihnen durch­füh­ren können.

Wofür werden Java-Listen verwendet?

Listen sind eine der grund­le­gen­den Da­ten­struk­tu­ren in der Java-Pro­gram­mie­rung und haben eine breite An­wen­dungs­pa­let­te. Sie be­inhal­ten Elemente in einer ge­ord­ne­ten Rei­hen­fol­ge, die hin­zu­ge­fügt, geändert, gelöscht oder abgefragt werden können. Die Objekte in einer Java List dürfen ver­schie­de­nen Klassen angehören. Zudem ist es möglich, doppelte oder Null-Elemente zu speichern. Außerdem un­ter­stüt­zen Java-Listen ge­ne­ri­sche Klassen und Methoden, was die Ty­pen­si­cher­heit ge­währ­leis­tet.

Ein­satz­ge­bie­te von Listen sind z. B. Da­ten­bank­an­wen­dun­gen, in denen sie dazu dienen, große Da­ten­sät­ze aus Da­ten­bank­ab­fra­gen auf­zu­be­wah­ren und auf sie zu­zu­grei­fen. In gra­fi­schen Be­nut­zer­ober­flä­chen werden Java-Listen oft verwendet, um eine Liste von Elementen an­zu­zei­gen, z. B. die Optionen in einem Drop-down-Menü oder die ver­schie­de­nen Artikel in einem On­line­shop.

Auch in Al­go­rith­men und Da­ten­struk­tu­ren ist Java List un­ver­zicht­bar. Sie wird bei der Im­ple­men­tie­rung von Sor­tier­al­go­rith­men, Such­al­go­rith­men oder Stapel- und War­te­schlan­gen­struk­tu­ren ein­ge­setzt. In Netz­werk­an­wen­dun­gen können Listen dazu beitragen, die Ver­wal­tung von Ver­bin­dun­gen und Sockets zu er­leich­tern.

Die Methoden der Java List

Java List gehört zur Coll­ec­tions-Schnitt­stel­le und muss aus dem Paket java.util im­por­tiert werden. Zu den Im­ple­men­tie­rungs­klas­sen gehören u. a. die Java ArrayList, Lin­ked­List, Vector und Stack. Sie können die ver­schie­de­nen Instanzen der Liste fol­gen­der­ma­ßen de­kla­rie­ren:

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

Hier sind einige der wich­tigs­ten Methoden, die in Ver­bin­dung 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 be­stimm­ten 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 an­ge­ge­be­ne Element am Ende der Liste hinzu.
7. boolean remove(Object o): Entfernt das erste Vorkommen eines be­stimm­ten 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 je­wei­li­gen 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 de­fi­nier­ten In­ter­valls.
12. default void replaceAll(UnaryOperator<E> operator): Stan­dard­me­tho­de in Java 8, die auf jedes Element unäre Java-Ope­ra­to­ren anwendet und das Ergebnis mit dem je­wei­li­gen Element ersetzt.

Typische An­wen­dungs­fäl­le von Java-Listen

Im Folgenden de­mons­trie­ren wir Ihnen die häu­figs­ten An­wen­dun­gen einer Java List. Dazu gehören Kon­ver­tie­run­gen von Arrays in Listen und umgekehrt sowie das Sortieren, Abrufen oder Ändern von Elementen.

Ein Array in eine Liste kon­ver­tie­ren

Zum Kon­ver­tie­ren in einen Array können Sie mit Schleifen eine Liste durch­lau­fen und durch die Methode .add() die Elemente der Reihe nach dem Array hin­zu­fü­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 kon­ver­tie­ren

Eine Liste kann mit der Methode toArray() in einen Array um­ge­wan­delt 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 be­stimm­ten Index zugreifen, während mit set() ein Objekt an einer ge­wünsch­ten Position aus­ge­tauscht und hin­zu­ge­fü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 Coll­ec­tions-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 auf­stei­gend sortiert auf dem Bild­schirm angezeigt:

4
26
57
92