Swipe um das Menü anzuzeigen

Beginnen wir mit der Einführung in die Datenstruktur List. Unten befindet sich ein Flussdiagramm, das die Hierarchie von Collections und Listen veranschaulicht. Das Diagramm wirkt möglicherweise umfangreich und komplex, aber wir werden es Schritt für Schritt aufschlüsseln.

In diesem Abschnitt wird ein bestimmter Typ von Collection behandelt, nämlich Listen. Es erfolgt eine genauere Betrachtung verschiedener Listentypen, darunter ArrayList, LinkedList und Stack.

Da alle Listen vom List-Interface erben, können Objekte über das übergeordnete Interface erstellt werden. Eine detaillierte Betrachtung folgt später.

Zunächst erfolgt die Besprechung des ersten Listentyps – ArrayList.

Oben ist die Syntax zur Erstellung einer ArrayList<> dargestellt. Ein Teil davon ist möglicherweise noch nicht bekannt – das Generic. Die Thematik Generics und deren Erstellung wird später behandelt.

Wichtig ist zunächst: Beim Erstellen einer ArrayList wird der Datentyp in spitzen Klammern angegeben. Zudem gilt: Listen können nicht mit primitiven Datentypen arbeiten. Stattdessen werden Wrapper-Klassen verwendet.

Im nächsten Schritt wird eine Liste im Code erstellt und einige Objekte mit der Methode add() hinzugefügt.

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.

Schauen wir uns nun ein Beispiel an, wie eine Liste mit unserem eigenen Datentyp erstellt wird:

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 Sie ein Array in eine Liste umwandeln können, lässt sich auch eine Liste mithilfe der Methode toArray() in ein Array konvertieren.

ArrayList<>-Methoden

Im Folgenden werden die grundlegenden Listenmethoden erläutert. Bisher hätten Sie Listen problemlos durch Arrays ersetzen können, aber hier liegt der entscheidende Unterschied—die Methoden.

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

Wenn Sie ein Element in die Mitte einer Liste einfügen, verschieben sich alle rechts davon liegenden Elemente um eine Position, um Platz für das neue Element zu schaffen.

Wenn Sie beispielsweise ein Element am Anfang der Liste hinzufügen, verschieben sich alle vorhandenen Elemente um eine Position nach rechts.

Hier ein 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:

Zugriff auf Elemente

Wenn Objekte an einer bestimmten Position in eine Liste eingefügt werden können, ist es selbstverständlich auch möglich, Objekte anhand ihres 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

Sie können hinzufügen, Sie können abrufen, aber können Sie auch löschen? Natürlich! Sie können Elemente mit der Methode remove(int index) entfernen.

Diese Methode ist ebenfalls überladen, das bedeutet, es gibt eine weitere Möglichkeit, ein Element zu entfernen. Sie können die Methode remove(Object obj) verwenden, die das erste Vorkommen des angegebenen Elements löscht.

Stellen Sie sich nun vor, Sie haben eine große Liste aller Studierenden in unserem Kurs. Allerdings hat sich ein Studierender schlecht benommen und wurde ausgeschlossen. Sie kennen seinen genauen Index nicht, daher müssen Sie ihn nach Namen entfernen. Aber es gibt ein Problem – der Code ist etwas fehlerhaft und der Name könnte mehrfach in der Liste vorkommen.

Schreiben wir ein Programm, um alle Vorkommen dieses Studierenden aus der Liste zu entfernen:

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"));
    }
}

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

Durch die Verwendung von contains() wird die Bedingung für die while-Schleife festgelegt, sodass alle Vorkommen eines Studenten wie "Bob" aus der Liste entfernt werden können.

Übrigens lässt sich dieser Vorgang mit der Methode removeAll(Collection<?> c) erheblich 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 wurde eine Collection von ausgeschlossenen Studenten erstellt und "Bob" hinzugefügt. Dadurch ist der Code leicht erweiterbar—es können im Laufe der Zeit einfach weitere Störenfriede zur Liste der ausgeschlossenen Studenten hinzugefügt werden.

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 nach 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—wir haben das Element am zweiten Index durch die Zahl 28 ersetzt.

Weitere Methoden

Sie haben bereits die gebräuchlichsten Methoden 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 Ihnen alle Felder und Methoden der Klasse angezeigt, sodass Sie weitere, möglicherweise noch unbekannte 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

Abschnitt 1. Kapitel 2

Liste und ArrayList in Java

ArrayList<>-Methoden

Zugriff auf Elemente

Entfernen von Elementen

Aktualisieren eines Werts nach Index

Weitere Methoden

1. Mit welcher Methode kann ein Element an einem bestimmten Index hinzugefügt werden?

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

3. Welche Methode kann verwendet werden, um das erste Vorkommen eines Elements zu entfernen?

4. Welche Methode kann verwendet werden, um ein Element anhand des Index zu ersetzen?

5. Welche Methode kann verwendet werden, um das Vorhandensein eines Elements zu überprüfen?

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

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