Java-Listen: Wichtige Methoden & smarte Anwendung

Die Java List ist dein ideales Werkzeug, wenn die Menge deiner Daten vorab unklar ist oder sich flexibel verändern soll. Wir zeigen dir pra­xis­na­he Beispiele für den Einsatz von Listen und welche Funk­tio­nen dir dabei den Alltag er­leich­tern.

Wofür nutzt du Java-Listen?

Listen gehören zu den es­sen­zi­el­len Da­ten­struk­tu­ren in Java und sind extrem viel­sei­tig. Sie speichern Elemente in einer fest­ge­leg­ten Abfolge, die du jederzeit erweitern, anpassen, löschen oder abrufen kannst. Dabei ist eine Java List flexibel: Die Objekte dürfen un­ter­schied­li­chen Klassen angehören, und auch Duplikate oder Null-Werte sind erlaubt. Dank der Un­ter­stüt­zung ge­ne­ri­scher Typen bleibst du zudem immer auf der sicheren Seite, was die Ty­pen­si­cher­heit betrifft.

Typische Ein­satz­be­rei­che findest du etwa in Da­ten­bank­an­wen­dun­gen. Hier helfen Listen dabei, um­fang­rei­che Da­ten­sät­ze aus Abfragen zwi­schen­zu­spei­chern. Auch bei Be­nut­zer­ober­flä­chen sind sie Standard: Ob Drop-down-Menüs oder die Ar­ti­kel­aus­wahl in einem On­line­shop – Listen halten die Daten im Hin­ter­grund bereit.

In der Welt der Al­go­rith­men ist die Java List ebenso un­ver­zicht­bar. Sie bildet die Basis für Sortier- und Such­vor­gän­ge sowie für Da­ten­struk­tu­ren wie Stacks oder Queues. Selbst bei Netz­werk­an­wen­dun­gen un­ter­stützt dich die Liste dabei, Ver­bin­dun­gen und Sockets effizient zu verwalten.

Die wich­tigs­ten Methoden der Java List

Da die Java List Teil der Coll­ec­tions-Schnitt­stel­le ist, musst du sie aus dem Paket java.util im­por­tie­ren. Bekannte Im­ple­men­tie­run­gen sind die Java ArrayList, Lin­ked­List, Vector und Stack. Deine Listen-Instanzen de­kla­rierst du ganz einfach so:

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

Hier ist eine Übersicht der Funk­tio­nen, mit denen du deine Java-Listen im Griff hast:

1. `int size(): Ermittelt, wie viele Elemente sich in der Liste befinden.
2. void add(int index, E element): Platziert ein Element an einer exakten Position.
3. boolean isEmpty(): Prüft auf einen Blick, ob die Liste leer ist.
4. void clear(): Leert die gesamte Liste mit einem Befehl.
5. boolean contains(Object o): Gibt true zurück, falls das Objekt o existiert.
6. boolean add(E e): Hängt ein neues Element direkt ans Ende an.
7. boolean remove(Object o): Löscht den ersten Treffer eines gesuchten Elements.
8. E get(int index): Ruft den Wert an einem spe­zi­fi­schen Index ab.
9. E set(int index, E element): Tauscht ein Element am Index aus oder fügt es dort ein.
10. Object[] toArray(): Wandelt die Liste in ein her­kömm­li­ches Array um.
11. List<E> subList(int fromIndex, int toIndex): Isoliert einen be­stimm­ten Bereich der Liste.
12. default void replaceAll(UnaryOperator<E> operator): Eine Java-8-Methode, die unäre Java-Ope­ra­to­ren auf alle Elemente anwendet und diese direkt ak­tua­li­siert.

Pra­xis­bei­spie­le für Java-Listen

Wir zeigen dir nun, wie du Java-Listen in der Praxis einsetzt. Erfahre, wie du Kon­ver­tie­run­gen zwischen Arrays und Listen meisterst und wie du Inhalte sortierst oder be­ar­bei­test.

So wird ein Array zur Liste

Um Daten in ein Array zu über­tra­gen, kannst du eine Liste per Schleife durch­lau­fen und die Elemente mit der Methode .add() nach­ein­an­der 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);
      }
    }

Das Ergebnis sieht dann so aus:

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

Eine Liste in ein Array umwandeln

Möchtest du eine Liste direkt in ein Array trans­for­mie­ren, nutzt du einfach die Methode toArray():

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 zeigt sich, dass alle Inhalte korrekt über­nom­men wurden:

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

Daten abrufen und be­ar­bei­ten

Mit get() greifst du gezielt auf einen Index zu. Die Methode set() erlaubt es dir, be­stehen­de Objekte an einer Position zu ersetzen oder neue hin­zu­zu­fü­gen.

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 Java bei 0 zu zählen beginnt, liefert der Code folgendes Resultat:

Element at index 1: b
a
b
d

Listen einfach sortieren

Um deine Java List in die richtige Rei­hen­fol­ge zu bringen, ist die Methode .sort() der Coll­ec­tions-Klasse ideal. Mit einer einfachen Schleife gibst du die sor­tier­ten Werte danach 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 er­schei­nen nun auf­stei­gend sortiert auf deinem Schirm:

4
26
57
92