Java ArrayList – Wie du deine Daten mit Listen organisierst.

Keylearnings:

• Welche Arten dynamischer Datenstrukturen gibt es?
• Was ist eine Java ArrayList?
• Wie kann man mit Generics den Datentyp bei Erstellung eines Objekts festlegen?
• Was ist ein Java Iterator?
• Wie kann man mit der erweiterten for Schleife die Elemente einer ArrayList ausgeben?
• Wie erzeugt man eine zweidimensionale ArrayList?
• Wie du eine ArrayList in ein Array umwandelst.
• Wie du ein Array in eine ArrayList konvertierst.

Herzlich willkommen zum zweiten Teil der Artikelserie über Java Datenstrukturen.

Solltest du den ersten Teil noch nicht gelesen haben, dann ist das für das Verständnis der ArrayList allerdings nicht schlimm.

Im ersten Teil dieser Serie haben wir die Frage geklärt, wofür wir Datenstrukturen benötigen und uns die einfachste Datenstruktur angesehen. Nämlich das Java Array.

Bei dem Java Array handelte es sich um eine statische Datenstrukur. Wir mussten bereits bei der Definition des Arrays angeben, wieviel Speicherplatz zu reservieren ist.

Dynamische Datenstrukturen können hingegen, während ihrer Lebenszeit, ihre Aufnahmekapazität verändern.

Es gibt unterschiedliche Typen an dynamischen Datenstrukturen. Java implementiert in seinen Klassen:

• Listen
• Mengen
• Assoziativspeicher
• Schlange

Mit den Listen werden wir uns in diesem Artikel intensiv beschäftigen, daher hierüber in Kürze mehr.

Vorher noch ein (sehr) kurzer Überblick über die anderen Arten von Datenstrukturen.

Mengen

Mengen sind eine Erfindung aus der Mathematik.

Eine Menge kannst du dir vorstellen wie eine Sammlung von Objekten. Das besondere hierbei ist, dass ein und dasselbe Objekt nicht zweimal in einer Menge vorkommen kann.

Wenn du also die Namen der Kinder einer Schulklasse in einer auf Mengen basierenden Datenstruktur speichern möchtest, hast du ein Problem sobald du zwei Martins in deiner Klasse hast.

Assoziativspeicher

Jedes Element in einem Assoziativspeicher besteht aus einem Schlüssel-Daten Paar. Jeden Datensatz, den du in einem Assoziativspeicher abspeicherst, muss mit einem Schlüssel versehen sein.

Über den Schlüssel kannst du dann auf einen abgespeicherten Datensatz zugreifen.

Im Grunde genommen kennst du das Prinzip des Assoziativspeichers von den Spind-Schränken in einer Badeanstalt.  Jeder Spind hat eine Nummer (der Schlüssel), über die du deine gesicherten Klamotten (Daten) wiederfindest.

Schlange

In einer Schlange ist das sogenannte FIFO (First in First out ), oder im Volksmund: „Wer als erstes kommt der malt zuerst“ Prinzip implementiert.

Das funktioniert genau wie bei dem Käsedealer deines Vertrauens. Derjenige, der sich als erstes in der Schlange anstellt bekommt den Käse zuerst.

Okay, nach dieser langen Vorrede kommen wir endlich zum Thema. Den Listen!

Die Klassen, welche die Listen-Funktionalitäten implementieren befinden sich in dem Paket java.util.

Deshalb musst du, in einer Klasse, in der du mit Listen arbeiten möchtest dieses Paket mit dem Schlüsselwort Import importieren.

Schreibe dazu einfach folgende Anweisung in den Kopf der Klassendatei.

import java.util.*;

Aus diesem Paket verwenden wir die Klasse ArrayList, die von der Oberklasse List abgeleitet ist.

Was ist eine Java ArrayList?

Wie der Name bereits vermuten lässt, ist eine ArrayList und ein Array eng miteinander verwandt.

Greifen wir das Beispiel von Frankas Einkaufsliste erneut auf!

Hier hatten wir die Artikel der Einkaufsliste in einem Java String Array gespeichert.

String[] artikel = new String[5];
artikel[0] = "Ei";
artikel[1] = "Schokolade";
artikel[2] = "Zahnpasta";
artikel[3] = "Banane";
artikel[4] = "Tiefkühlpizza";

Sehen wir uns an, wie wir dasselbe mit Hilfe einer ArrayList erreichen können.

Java ArrayList anlegen

Selbstverständlich beginnen wir auch hier wieder mit der Deklaration.

Entscheidend hierbei ist, dass wir keine Angaben über die Größe des zu reservierenden Speicherplatz machen.

ArrayList<String> einkaufsListe = new ArrayList<>();

Alles klar Kim! Wir erzeugen eine ArrayList Instanz mit dem Namen einkaufsListe. Aber was haben die spitzen Klammern zu bedeuten?

Das ist ein cooles Java Feature, das man Generics nennt. Hiermit kannst du die Datentypen in einer Klasse dynamisch festlegen.

So herrscht z.B. Uneinigkeit darüber, ob eine Kontonummer eine Zeichenkette oder ein numerischer Wert ist.

Da man den Datentyp mit Hilfe von Generics erst bei Verwendung der Klasse Bankdaten festlegen muss, ist das aber, zumindest in der Designphase, kein Problem mehr.

Aber die Generics sind ein Thema, die einen eigenen Artikel verdient haben.

Für den Moment reicht es aus, dass du verstehst, dass obiger Ausdruck eine ArrayList erzeugt, in der du Elemente vom Datentyp String speichern kannst.

Java ArrayList initialisieren

Aber wie fügen wir Elemente in die Liste ein?

Hierfür besitzt ein ArrayList Objekt die Methode add, welche als Parameter den Wert erwartet, der in die Liste eingefügt werden soll.

Speichern wir die Artikel der Einkaufsliste in einer ArrayList.

einkaufsListe.add("Ei");
einkaufsListe.add("Schokolade");
einkaufsListe.add("Zahnpasta");
einkaufsListe.add("Banane");
einkaufsListe.add("Tiefkühlpizza");

Einfach! Oder? Wir fügen einfach jeden Artikel über die Methode add in die Liste ein.

Ausgabe der Elemente der ArrayList

Soweit so gut, aber wie geben wir die Daten der ArrayList aus?

Hier gibt es zwei Möglichkeiten.

Die erste ist, die Daten genau wie bei einem Array über einen Index abzufragen und auszugeben. Hierfür gibt es die Objektmethode get, die den Index des Elements, auf das wir zugreifen wollen als Parameter erwartet.

Wir können die ArrayList also mit einer for Schleife durchlaufen und jedes Element einzeln ausgeben.

Die Anzahl der Elemente können wir hierbei mit der size Methode abfragen.

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

Die Vorgehensweise ist also genau wie bei einem Array, das wir vollständig auf dem Bildschirm ausgeben wollen.

Einziger Unterschied ist, dass wir anstatt der Array length Eigenschaft die Methode size() aufrufen um herauszufinden wie weit der Index i laufen muss.

Ich schätze die Programmausgabe hast du längst erraten.

Ei
Schokolade
Zahnpasta
Banane
Tiefkühlpizza

Wie erwartet, werden alle Artikel in der Liste der Reihe nach auf dem Bildschirm ausgegeben.

Was ist ein Java Iterator?

Eine elegantere Methode das gleiche zu erreichen, ist die Verwendung eines sogenannten Java Iterators.

Genauer gesagt in unserem Fall der ListIterator. Der ListIterator ist ein in die Klasse List eingebundenes java interface, mit dem du in deiner Liste navigieren kannst.

Bildlich kannst du dir einen Iterator wie einen beweglichen Pfeil vorstellen, der auf ein Element in deiner Liste zeigt. Diesen Pfeil kannst du nach oben und unten bewegen. Das Element, auf das der Pfeil zeigt ist aktuell im Zugriff.

Der ListIterator stellt Methoden zur Verfügung, mit denen der Pfeil nach unten (next()) und nach oben (previous()) bewegt werden kann.

Sowohl die Methode next, als auch previous liefert den Datensatz zurück, auf dem der Iterator vor Aufruf der Methode steht.

Kim, das sind alles coole Features! Aber wie hilft uns das weiter?

Naja, wir können den Iterator jetzt durch die Liste bewegen und jedes Element der Reihe nach ausgeben.

Da wir außerdem mit der Iterator-Methode hasNext() überprüfen können, ob wir das Ende der Liste erreicht haben, ist die do-while Schleife hierfür ein hervorragendes Werkzeug.

In der Praxis müssen wir allerdings im ersten Schritt erstmal einen Iterator, der auf unsere ArrayList zeigt erzeugen.

Hierfür hat das ArrayList Objekt die Methode ListIterator, die als Rückgabewert einen entsprechenden Iterator liefert.

Der Methode ListIterator kann optional der Index, an welcher der Iterator starten soll, mitgegeben werden.

Wir wollen unsere Liste vom ersten bis zum letzten Eintrag durchlaufen, deshalb erzeugen wir einen Iterator, der zu Beginn am Listenanfang, also der Position mit dem Index 0 steht.

ListIterator<String> artikelIterator = einkaufsListe.listIterator(0);

Auch hier verwenden wir Java Generics um einen Iterator zu erzeugen, der auf ein String Objekt zeigt.

Unser Plan sieht vor, unsere ArrayList mit einer do-while Schleife zu durchlaufen. Auf geht’s!

1: do{
2:     System.out.println(artikelIterator.next());
3:}while(artikelIterator.hasNext());

Was passiert hier?

In der do-while Schleife wird bei jedem Durchlauf der Datensatz, auf den der Iterator zeigt ausgegeben und gleichzeitig auf das nächste Element in der ArrayList geschoben.

Dieses Prozedre wird solange wiederholt, bis wir beim letzten Element angekommen sind und die Methode hasNext den Wahrheitswert false zurückliefert und so für einen Abbruch der do-while Schleife sorgt.

Die Programmausgabe ist also die gleiche, die wir bereits oben erhalten hatten.

Ei
Schokolade
Zahnpasta
Banane
Tiefkühlpizza

Seit JAVA 5 gibt es eine weitere Möglichkeit wie du eine Liste durchlaufen kannst. Und zwar die erweiterte for-Schleife.

Die erweiterte for Schleife

Die Ideen die hier zugrunde liegen sind dieselben, die ich dir bereits gezeigt habe. Allerdings ermöglicht die erweiterte for Schleife eine weitaus kompaktere Schreibweise.

Folgender Programmschnipsel liefert die gleiche Funktionalität wie unsere do while Schleife von oben.

for (ListIterator li = einkaufsListe.listIterator(0); li.hasNext();){
	System.out.println(li.next());
}

In einer erweiterten for Schleife können wir den Iterator li genau wie eine Zählervariable definieren und anstatt, wie in einer üblichen for Schleife, ein Inkrement durchzuführen rufen wir die hasNext Methode auf.

Die Schleife läuft solange bis hasNext den Wahrheitswert false zurückliefert, d.h. das Ende der Liste erreicht ist.

Im Schleifenrumpf werden die Listenelemente ausgegeben und der Iterator mit Hilfe der next Methode nach vorne geschoben.

Noch nicht überzeugt? Na gut! Damit du mir glaubst hier die Programmausgabe.

Ei
Schokolade
Zahnpasta
Banane
Tiefkühlpizza

Im folgenden Video zeige ich dir nochmal Schritt für Schritt wie du die besprochenen Schritte in der IDE Eclipse durchführst.

Kim, war das schon alles?

Nein, natürlich nicht! Die ArrayList hat in Kombination mit dem Iterator noch so einiges auf Lager. Wir werden uns auch noch einige Features ansehen.

So kannst du z.B. mit der ArrayList Methode remove einzelne Elemente aus der Liste löschen, indem du den Index des Listeneintrags, den du löschen möchtest als Parameter an diese Methode übergibst.

Für einen Überblick über alle Methoden der Java ArrayList und des Java Iterators empfehle ich dir folgende Ressource.

Wenn du es allerdings bis hierhin geschafft hast, dann hast du das Prinzip der ArrayList auf jeden Fall verstanden.

Aber fehlt dir nicht noch irgendetwas?

Ein Java Array konnten wir mehrdimensional definieren.

Ich kann dich beruhigen, das können wir auch bei einer ArrayList machen.

Hier funktkioniert das allerdings etwas anders. Schauen wir uns nochmal an wie wir eine ArrayList deklariert haben.

ArrayList einkaufsListe = new ArrayList();

Eine wesentliche Rollen spielen hierbei die Java Generics!

Was passiert, wenn wir in die spitzen Klammern, die zu den Generics gehören einfach ArrayList schreiben?

Probieren wir das doch mal aus!

ArrayList<ArrayList> einkaufsListe = new ArrayList<ArrayList>();

Sieht komisch aus, aber der Compiler frisst es! Aber was hat das zu bedeuten?

Bei sowas sprechen wir von geschachtelten Generics. Jedes Element dieser ArrayList ist wieder eine ArrayList deren Elemente Strings sind.

Auf diese Weise können wir eine zweidimensionale ArrayList aufbauen.

Halten wir uns an das Beispiel, welches wir bereits bei den Arrays betrachtet haben. Wir wollen folgende Tabelle speichern!

	0	1
0	Straussenei	Milch von weißer Kuh
1	Hühnerei	Milch von brauner Kuh

Jede Zeile dieser Tabelle speichern wir in einer eigenen ArrayList. Und jetzt wird es krass! 🙂

Wir haben zwei Zeilen, daher legen wir ein zweielementiges ArrayList Array an, welches wir mit den beiden Listen für die Zeilen der Tabelle initialisieren.

ArrayList[] artikelZeilen = new ArrayList[2];
artikelZeilen[0] = new ArrayList();
artikelZeilen[1] = new ArrayList();

Im nächsten Schritt initialisieren wir die in den Array Elementen gespeicherten Listen mit den Texten aus der Tabelle. Also in Programmcode ausgedrückt:

artikelZeilen[0].add("Straussenei");
artikelZeilen[0].add("Milch von weißer Kuh");
artikelZeilen[1].add("Hühnerei");
artikelZeilen[1].add("Milch von brauner Kuh");

In einem letzten Initialisierungsschritt müssen wir die beiden ArrayList’s, die in unserem Array gespeichert sind, noch in die ArrayList einkaufsListe einfügen.

Puuh! Das klingt kompliziert, ist aber in Wirklichkeit halb so wild wie du an folgendem Programmcode erkennen kannst.

einkaufsListe.add(artikelZeilen[0]);
einkaufsListe.add(artikelZeilen[1]);

Die Ausgabe einer zweidimensionalen ArrayList.

So damit du siehst, dass der Programmcode auch wirklich funktioniert, geben wir den Inhalt der zweidimensionalen ArrayList auf dem Bildschirm aus.

Hierfür verwenden wir eine verschachtelte erweiterte for Schleife.

for (ListIterator<ArrayList> li = einkaufsListe.listIterator(0); li.hasNext();){
	for(ListIterator li2 = li.next().listIterator(0); li2.hasNext(); ){
		System.out.println(li2.next());	
	}
}

In der ersten for Schleife durchlaufen wir die komplette ArrayList einkaufsListe mit Hilfe des Iterators li.

Die Elemente von einkaufsListe sind ebenfalls Listen, die wir in der zweiten for Schleife mit dem Iterator li2 durchlaufen und deren Elemente auf dem Bildschirm ausgeben.

Was zu folgender Programmausgabe führt:

Straussenei
Milch von weißer Kuh
Hühnerei
Milch von brauner Kuh

Umwandlung eines Arrays in eine ArrayList und umgekehrt

Häufig arbeiten bereits entwickelte Methoden mit Arrays.

Da eine ArrayList und ein Array so eng miteinander verbandelt sind, wäre es schade, wenn wir diese Methoden nicht nutzen könnten, nur weil wir mit einer ArrayList anstatt eines Arrays arbeiten.

Aber auch hier hilft uns die JAVA Programmbibliothek aus der Patsche.

Wir können mit Hilfe der Methode toArray eine Liste in ein Array umwandeln.

Probieren wir das mal mit Franka’s Einkaufsliste aus!

String[] einkaufsListeArray = einkaufsListe.toArray();

Oh Mist! 🙁 Ein Kompilierungsfehler!!

Woran liegt’s?

Die toArray() Methode ist Typ unabhängig!

Leider aber nicht in dem Sinne, dass der Rückgabetyp mit Hilfe von Generics festgelegt werden kann, sondern in dem Sinne, dass toArray den allgemeinsten Datentyp zurückliefert.

Und was war nochmal der allgemeinste Datentyp in Java?

Ganz genau! Der Datentyp Object. Die Mutter aller Klassen.

Aber wir können es ja mal mit einer Typkonvertierung versuchen. Hierzu schreiben wir einfach den gewünschten Datentyp in Klammern vor die Zuweisung.

Probieren wir es erneut!

String[] einkaufsListeArray = (String[]) einkaufsListe.toArray();

Jetzt kannst du den Programmcode wenigstens kompilieren. Aber beim dem Versuch das Programm auszuführen, erhalten wir eine ClassCastException Ausnahme.

Was ist jetzt schon wieder in die Hose gegangen?

Die Methode toArray liefert ein Array zurück. Dank der Typkonvertierung können wir das auch in dem String Array einkaufsListe abspeichern.

Leider hält die Typkonvertierung die toArray Methode nicht davon ab, zu versuchen einen Object Datentyp in die einzelnen Elemente des Arrays zu schreiben. Und da diese vom Typ String sind, kommt es zu einer ClassCastingException.

Aber auch hieran haben die Entwickler von Java gedacht und eine Technik Namens Reflection eingeführt.

Ohne zu sehr ins Detail gehen zu wollen, haben wir hierdurch die Möglichkeit der toArray Methode ein Array Element mitzugeben, anhand dem festgestellt werden kann von welchem Datentyp die Elemente im Rückgabe-Array sein müssen.

Und das geht so!

String[] einkaufsListeArray = (String[]) einkaufsListe.toArray(new String[0]);

Super! Das Programm geht sauber durch den Compiler und meckert auch während der Laufzeit nicht rum.

Ich weiß du bist misstrauisch, daher wollen wir das Array einmal auf dem Bildschirm ausgeben.

for (int i = 0;i<einkaufsListeArray.length;i++){
	System.out.println(einkaufsListeArray[i]);
}

Und Trommelwirbel! Hier die Programmausgabe:

Ei
Schokolade
Zahnpasta
Banane
Tiefkühlpizza

Ein Array in eine Liste umzuwandeln sorgt glücklicherweise für deutlich weniger Verwirrung!

Mit der Klassenmethode asList aus der Klasse Arrays können wir ein Array in eine ArrayList verwandeln.

Wenden wir diese Methode auf einkaufsListeArray an und erzeugen eine ArrayList neueListe

ArrayList neueListe = new ArrayList(Arrays.asList(einkaufsListeArray));

Neu hierbei ist, dass wir nicht den Standard-Konstruktor verwenden, sondern dem Konstruktor eine Initialliste mitgeben, mit deren Werten die Liste neueListe vorbelegt wird.

In unserem Fall erzeugen wir diese Initialliste mit Hilfe der asList Methode aus dem Array einkaufsListeArray.

Um alten Gewohnheiten zu folgen, geben wir wieder den Inhalt der ArrayList neueListe mit Hilfe eines Java Iterators und der erweiterten for Schleife auf dem Bildschirm aus.

for (ListIterator li = neueListe.listIterator(0); li.hasNext();){
	System.out.println(li.next());
}

Hier die Programmausgabe, die du bestimmt schon Auswendig kennst.

Ei
Schokolade
Zahnpasta
Banane
Tiefkühlpizza

Ich hoffe ich konnte dir in diesem Artikel ein gutes Verständnis der Java ArrayList vermitteln. Im nächsten Teil der Serie schauen wir uns die Linked List (verkettete Liste) an.

Wie immer freue ich mich über deine Fragen im Kommentarbereich!

Hat dir der Artikel gefallen? Dann folge uns doch am besten gleich auf Facebook!