ArrayList

Eine konkrete Umsetzung einer List: Die ArrayList.

java.util.ArrayList

java.util.ArrayList erbt von der abstrakten Klasse java.util.AbstractList und liefert eine konkrete Implementierung für das Interface java.util.List. Die ArrayList Klasse implementiert alle Methoden des Interface java.util.List. Der Implementierung der ArrayList Klasse liegen Arrays zugrunde, weshalb diese konkrete Klasse auch ArrayList heisst. Die Klasse ArrayList enthält also ein normales Array. Wenn ein Element hinzugefügt wird, wird es in dieses Array eingefügt. Wenn das Array nicht gross genug ist, wird ein neues, grösseres Array erstellt, um das alte zu ersetzen, d.h. die Kapazität des Arrays wird fortlaufend angepasst.

Methodenübersicht

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

/*
 * Konstruktor: Erstellt eine initial leere Liste
 */
public ArrayList<E>()

/*
 * Appends the specified element to the end of this list.
 */
public boolean add(E e)

/*
 * Fügt das angegebene Element an der angegebenen Position in diese Liste ein.
 */
public void add(int index,E element)

/*
 * Entfernt alle Elemente aus dieser Liste.
 */
public void clear()

/*
 * Entfernt das Element an der angegebenen Position in dieser Liste.
 */
public E remove(int index)

/*
 * Gibt das Element an der angegebenen Position in dieser Liste zurück.
 */
public E get(int index)

/*
 * Gibt den Index des ersten Auftretens des angegebenen Elements in dieser Liste zurück,
 * oder -1, wenn diese Liste das Element nicht enthält.
 */
public int indexOf(Object o)

/*
 * Gibt die Anzahl der Elemente in dieser Liste zurück.
 */
public int size()

/*
 * Gibt true zurück, wenn diese Liste keine Elemente enthält.
 */
public boolean isEmpty()

/*
 * Gibt true zurück, wenn diese Liste das angegebene Element enthält.
 */
public boolean contains(Object o)
Beispiel

IndexOutOfBoundsException

Eine der häufigsten Exceptions, die im Zusammenhang mit Listen auftritt, ist folgende: Es wird versucht, auf ein Element mit einem Index zuzugreifen, wobei der Index grösser als (oder gleich wie) die Länge der Liste ist. Dann wird die IndexOutOfBoundsException geworfen:

1
2
3
4
5
6

List<String> list = new ArrayList<>();
list.add("uno");
list.add("dos");
list.add("tres");

System.out.println(list.get(3));

Hier wird dann diese Meldung angezeigt:

1

"java.lang.IndexOutOfBoundsException: Index 3 out of bounds for length 3"

Der Fehler war hier, dass die Liste 3 Elemente enthielt, und versucht wird, auf das 4. Element (also Index 3) zuzugreifen. Weil das 4. Element in dieser Liste nicht existiert, wird eine Exception geworfen.

Ganz generell wird die IndexOutOfBoundException geworfen, wenn versucht wird, auf einen ungültigen Index innerhalb einer Collection zuzugreifen. Hat eine Liste die Grösse x:

  • dann sind die gültigen Indizes, um auf Elemente zuzugreifen 0, 1, 2, …, x-1
  • und die Indizes x, x+1, x+2, … wären ungültig.

Diese Exception kann bei den folgenden Methoden von oben geworfen werden: (Diese Liste hier ist genau so nicht vollständig, wie die oben.)

  • public void add(int index, E element) (beachte das Argument index.)
  • public E remove(int index)
  • public E get(int index)

Beispiel

Beispiel 1 - ArrayList

Im folgenden Beispiel erstellen wir zunächst eine leere ArrayList mit Elementen vom Typ String und wenden einige einfache ArrayList Methoden an und sehen, wie diese funktionieren (Das Hinzufügen von Elementen, das Entfernen von Elementen, …),

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


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

public class Pets {

    public static void main(String[] args) {
        // Creating an ArrayList of String
        List<String> pets = new ArrayList<>();

        System.out.println(pets); // Output: []

        // Adding new elements to the ArrayList
        pets.add("Cat");
        pets.add("Hamster");
        pets.add("Dog");
        pets.add("Goldfish");

        System.out.println(pets); // Output: [Cat, Hamster, Dog, Goldfish]

        // Adding an element at a particular index in an ArrayList
        pets.add(2, "Guinea pigs");

        System.out.println(pets); // Output: [Cat, Hamster, Guinea pigs, Dog, Goldfish]

        pets.remove(2);

        System.out.println(pets); // Output: [Cat, Hamster, Dog, Goldfish]

        pets.remove("Dog");

        System.out.println(pets); // Output: [Cat, Hamster, Goldfish]

        pets.clear();

        System.out.println(pets); // Output: []
    }
}

Beispiel 2 - for-Schleife

Dieses Beispiel zeigt auf wie mit einer for-Schleife über die Elemente einer Liste iteriert werden kann.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import java.util.ArrayList;

class ListSum {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1000);
        numbers.add(2500);
        numbers.add(3750);
        numbers.add(625);

        int listSum = 0;

        for (Integer e : numbers) {
            listSum += e;
        }

        System.out.println("Die Summe der Elemente beträgt " + listSum);
    }
}

Output:

1
2

Die Summe der Elemente beträgt 7875

Beispiel 3 - while-Schleife

Dieses Beispiel zeigt auf wie mit einer while-Schleife über die Elemente einer Liste iteriert werden kann.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

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

public class WhileLoopExample {

  public static void main(String[] args) {
    String[] namesArray = { "Anna", "Simon", "Jan", "Nicole"};

    // convert array to list
    List<String> namesArrayList = Arrays.asList(namesArray);

    int i = 0;
    while (i < namesArrayList.size()) {
      System.out.println(namesArrayList.get(i));
      i++;
    }
  }
}

Output:

1
2
3
4
5

Anna
Simon
Jan
Nicole
Aufgaben

Aufgaben

Aufgaben zu Modul #J7 - Java Collections - List

Previous
Next
Last modified July 25, 2023: replace ß with ss (e263997b)