Beginnen wir mit unserer Einführung in die Datenstruktur List. Unten befindet sich ein Flussdiagramm, das die Hierarchie von Collections und Listen veranschaulicht. Es mag wie ein großes und komplexes Diagramm erscheinen, aber wir werden es Schritt für Schritt aufschlüsseln.

In diesem Abschnitt untersuchen Sie einen bestimmten Typ von Collection, nämlich Listen. Sie betrachten verschiedene Listentypen genauer, darunter ArrayList, LinkedList und Stack.

Da alle Listen vom List-Interface erben, können Objekte mit dem übergeordneten Interface erstellt werden. Darauf gehen wir später noch genauer ein.

Zunächst besprechen wir den ersten Listentyp – die ArrayList.

Oben sehen Sie die Syntax zur Erstellung einer ArrayList<>. Ein Teil davon ist Ihnen möglicherweise noch nicht vertraut – das Generic. Wir behandeln Generics und deren Erstellung später.

Merken Sie sich vorerst, dass beim Erstellen einer ArrayList der Datentyp in spitzen Klammern angegeben wird. Beachten Sie außerdem, dass Listen nicht mit primitiven Datentypen arbeiten können. Stattdessen werden Wrapper-Klassen verwendet.

Nun erstellen wir eine Liste im Code und fügen mit der Methode add() einige Objekte hinzu.

Main.java


              1234567891011121314
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Wie Sie sehen, ist die Methode add() sehr unkompliziert – sie fügt einfach den angegebenen Wert zur Liste hinzu.

Beachten Sie außerdem, dass Sie List und ArrayList aus der Bibliothek java.util importieren müssen. Wenn Sie jedoch IntelliJ IDEA verwenden, werden diese Bibliotheken automatisch importiert, sodass Sie sich darüber keine Gedanken machen müssen.

Sehen wir uns nun ein Beispiel für die Erstellung einer Liste mit unserem eigenen Datentyp an:

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Wie Sie sehen, haben wir unsere eigene Klasse Dog erstellt und eine ArrayList mit diesem Datentyp verwendet. Beim Ausgeben der Liste wurden alle darin gespeicherten Objekte angezeigt.

Was ist, wenn ein Array vorliegt und dieses in eine Liste umgewandelt werden soll? Dies kann mit der Methode asList() aus der Klasse Arrays erfolgen.

Mit dieser Methode lässt sich eine Liste erstellen, die die gleichen Elemente wie das ursprüngliche Array enthält. Dies ist besonders nützlich, wenn Listenmethoden auf ein Array angewendet werden sollen. Die Syntax ist einfach:

Arrays.asList(arrayName);

Und sie kann direkt bei der Initialisierung einer neuen Liste verwendet werden, zum Beispiel:

Main.java


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Genauso wie ein Array in eine Liste umgewandelt werden kann, lässt sich auch eine Liste mithilfe der Methode toArray() in ein Array konvertieren.

ArrayList<>-Methoden

Überblick über die grundlegenden Listenmethoden. Bisher hätten Listen problemlos durch Arrays ersetzt werden können, aber hier liegt der entscheidende Unterschied—die Methoden.

Die Methode add() ist eine überladene Methode, das heißt, sie existiert in mehreren Varianten. Eine davon ermöglicht das Hinzufügen eines Elements an einem bestimmten Index.

Beim Einfügen eines Elements in die Mitte einer Liste verschieben sich alle rechts davon liegenden Elemente um eine Position, um Platz für das neue Element zu schaffen.

Wenn beispielsweise ein Element am Anfang der Liste hinzugefügt wird, verschieben sich alle vorhandenen Elemente um eine Position nach rechts.

Beispiel:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

Die Verschiebung der Werte beim Einfügen eines Elements lässt sich in der folgenden Abbildung veranschaulichen:

Elemente abrufen

Selbstverständlich ist es möglich, wenn Objekte an einem bestimmten Index zu einer Liste hinzugefügt werden können, diese auch über ihren Index mit der Methode get(int index) abzurufen.

Im Folgenden ein Beispiel:

Main.java


              12345678910111213141516171819
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Entfernen von Elementen

Hinzufügen ist möglich, Abrufen ebenso – aber ist auch das Löschen möglich? Natürlich! Elemente können mit der Methode remove(int index) entfernt werden.

Diese Methode ist zudem überladen, das heißt, es gibt eine weitere Möglichkeit, ein Element zu entfernen. Mit der Methode remove(Object obj) wird das erste Vorkommen des angegebenen Elements gelöscht.

Stellen wir uns nun vor, Sie haben eine große Liste aller Kursteilnehmer. Allerdings hat sich ein Teilnehmer falsch verhalten und wurde aus dem Kurs ausgeschlossen. Der genaue Index ist nicht bekannt, daher muss der Teilnehmer per Name entfernt werden. Es gibt jedoch ein Problem: Der Code ist fehlerhaft und der Name könnte mehrfach in der Liste vorkommen.

Im Folgenden wird ein Programm geschrieben, das alle Vorkommen dieses Teilnehmers aus der Liste entfernt:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Möglicherweise ist Ihnen aufgefallen, dass wir eine weitere Listenmethode verwendet haben—contains(Object obj). Diese Methode prüft, ob das angegebene Element in der Liste vorhanden ist, und gibt true oder false zurück.

Mit contains() legen wir die Bedingung für die while-Schleife fest, sodass wir alle Vorkommen eines Studenten wie "Bob" aus der Liste entfernen können.

Übrigens lässt sich dieser Vorgang mit der Methode removeAll(Collection<?> c) deutlich vereinfachen:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Die Methode removeAll() nimmt eine Collection als Parameter entgegen, die Werte enthält, die aus der Liste entfernt werden, auf der die Methode aufgerufen wurde.

In diesem Ansatz haben wir eine Collection der ausgeschlossenen Studenten erstellt und "Bob" hinzugefügt. Dadurch ist unser Code leicht erweiterbar—Sie können im Laufe der Zeit einfach weitere Störenfriede zur Liste der ausgeschlossenen Studenten hinzufügen.

Aktualisieren eines Werts nach Index

Kehren wir zu den Listenmethoden zurück—nun ist die Update-Methode an der Reihe.

Da die Methode add() beim Einfügen eines neuen Werts einfach alle Elemente nach rechts verschiebt, benötigen wir eine andere Möglichkeit, um einen bestehenden Wert anhand des Index zu aktualisieren.

Die Methode set(int index, Object value) erfüllt genau diese Aufgabe:

Main.java


              12345678910111213141516
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

Das Vorgehen ist recht einfach—das Element am zweiten Index wurde durch die Zahl 28 ersetzt.

Weitere Methoden

Die wichtigsten Methoden wurden bereits behandelt, aber es gibt noch viele weitere. Da diese selten verwendet werden, gehen wir nicht auf jede einzelne ein.

Stattdessen finden Sie alle benötigten Methoden – zusammen mit vollständiger Dokumentation und ausführlichen Erklärungen – indem Sie die Klasse ArrayList in IntelliJ IDEA öffnen.

Importieren Sie dazu einfach die ArrayList-Bibliothek, halten Sie die Command key (Ctrl unter Windows) gedrückt und klicken Sie auf ArrayList. So werden alle Felder und Methoden der Klasse angezeigt, sodass Sie auch weniger bekannte Methoden entdecken können.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 2

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Swipe um das Menü anzuzeigen

In diesem Abschnitt untersuchen Sie einen bestimmten Typ von Collection, nämlich Listen. Sie betrachten verschiedene Listentypen genauer, darunter ArrayList, LinkedList und Stack.

Da alle Listen vom List-Interface erben, können Objekte mit dem übergeordneten Interface erstellt werden. Darauf gehen wir später noch genauer ein.

Zunächst besprechen wir den ersten Listentyp – die ArrayList.

Nun erstellen wir eine Liste im Code und fügen mit der Methode add() einige Objekte hinzu.

Main.java


              1234567891011121314
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Wie Sie sehen, ist die Methode add() sehr unkompliziert – sie fügt einfach den angegebenen Wert zur Liste hinzu.

Sehen wir uns nun ein Beispiel für die Erstellung einer Liste mit unserem eigenen Datentyp an:

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Wie Sie sehen, haben wir unsere eigene Klasse Dog erstellt und eine ArrayList mit diesem Datentyp verwendet. Beim Ausgeben der Liste wurden alle darin gespeicherten Objekte angezeigt.

Was ist, wenn ein Array vorliegt und dieses in eine Liste umgewandelt werden soll? Dies kann mit der Methode asList() aus der Klasse Arrays erfolgen.

Arrays.asList(arrayName);

Und sie kann direkt bei der Initialisierung einer neuen Liste verwendet werden, zum Beispiel:

Main.java


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Genauso wie ein Array in eine Liste umgewandelt werden kann, lässt sich auch eine Liste mithilfe der Methode toArray() in ein Array konvertieren.

ArrayList<>-Methoden

Überblick über die grundlegenden Listenmethoden. Bisher hätten Listen problemlos durch Arrays ersetzt werden können, aber hier liegt der entscheidende Unterschied—die Methoden.

Die Methode add() ist eine überladene Methode, das heißt, sie existiert in mehreren Varianten. Eine davon ermöglicht das Hinzufügen eines Elements an einem bestimmten Index.

Beim Einfügen eines Elements in die Mitte einer Liste verschieben sich alle rechts davon liegenden Elemente um eine Position, um Platz für das neue Element zu schaffen.

Wenn beispielsweise ein Element am Anfang der Liste hinzugefügt wird, verschieben sich alle vorhandenen Elemente um eine Position nach rechts.

Beispiel:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

Die Verschiebung der Werte beim Einfügen eines Elements lässt sich in der folgenden Abbildung veranschaulichen:

Elemente abrufen

Im Folgenden ein Beispiel:

Main.java


              12345678910111213141516171819
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Entfernen von Elementen

Hinzufügen ist möglich, Abrufen ebenso – aber ist auch das Löschen möglich? Natürlich! Elemente können mit der Methode remove(int index) entfernt werden.

Im Folgenden wird ein Programm geschrieben, das alle Vorkommen dieses Teilnehmers aus der Liste entfernt:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Mit contains() legen wir die Bedingung für die while-Schleife fest, sodass wir alle Vorkommen eines Studenten wie "Bob" aus der Liste entfernen können.

Übrigens lässt sich dieser Vorgang mit der Methode removeAll(Collection<?> c) deutlich vereinfachen:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Die Methode removeAll() nimmt eine Collection als Parameter entgegen, die Werte enthält, die aus der Liste entfernt werden, auf der die Methode aufgerufen wurde.

Aktualisieren eines Werts nach Index

Kehren wir zu den Listenmethoden zurück—nun ist die Update-Methode an der Reihe.

Die Methode set(int index, Object value) erfüllt genau diese Aufgabe:

Main.java


              12345678910111213141516
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

Das Vorgehen ist recht einfach—das Element am zweiten Index wurde durch die Zahl 28 ersetzt.

Weitere Methoden

Die wichtigsten Methoden wurden bereits behandelt, aber es gibt noch viele weitere. Da diese selten verwendet werden, gehen wir nicht auf jede einzelne ein.

Stattdessen finden Sie alle benötigten Methoden – zusammen mit vollständiger Dokumentation und ausführlichen Erklärungen – indem Sie die Klasse ArrayList in IntelliJ IDEA öffnen.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 2

List und ArrayList in Java

ArrayList<>-Methoden

Elemente abrufen

Entfernen von Elementen

Aktualisieren eines Werts nach Index

Weitere Methoden

1. Mit welcher Methode kann ein Element anhand des Index hinzugefügt werden?

2. Mit welcher Methode kann ein Element anhand des Index abgerufen werden?

3. Mit welcher Methode kann das erste Vorkommen eines Elements entfernt werden?

4. Mit welcher Methode kann ein Element anhand des Index ersetzt werden?

5. Mit welcher Methode kann das Vorhandensein eines Elements überprüft werden?

6. Können wir eine Liste aus einem Array erstellen?

7. Wie können wir eine Liste aus einem Array erstellen?

List und ArrayList in Java

ArrayList<>-Methoden

Elemente abrufen

Entfernen von Elementen

Aktualisieren eines Werts nach Index

Weitere Methoden

1. Mit welcher Methode kann ein Element anhand des Index hinzugefügt werden?

2. Mit welcher Methode kann ein Element anhand des Index abgerufen werden?

3. Mit welcher Methode kann das erste Vorkommen eines Elements entfernt werden?

4. Mit welcher Methode kann ein Element anhand des Index ersetzt werden?

5. Mit welcher Methode kann das Vorhandensein eines Elements überprüft werden?

6. Können wir eine Liste aus einem Array erstellen?

7. Wie können wir eine Liste aus einem Array erstellen?