Javakurs/Übungsaufgaben/ArrayList
Eine ArrayList ist ein Hilfsmittel, um Listen mit sich ändernder Größe zu verwalten. Sie sind im 'Lieferumfang' von Java enthalten.
Javadoc zu ArrayList
Inhaltsverzeichnis
Arrays - Wozu benötigen wir eine ArrayList?
Wenn man ein Array benutzt, so muss man schon beim Anlegen wissen, wieviele Elemente man darin speichern will.
Im Code sieht das so aus:
int[] foo = new int[4];
Will man nun aber 5 Elemente in dem schon angelegten Array speichern, so müsste man erst ein größeres Array anlegen und dann alle Elemente kopieren:
//wir wollen ein 5. Element - was nun?!
int[] bar = new int[5]; // neues Array erzeugen
for (int i=0;i<foo.length;i++){ // array durchlaufen
bar[i]=foo[i]; // Werte kopieren
}
foo=bar; //alte Referenz überschreiben
foo[5] = 5; // Wert hinzufügen
Auf Dauer ist das keine Lösung, zumal dies bei jedem weiteren Vergrößern notwendig wird - je länger das Array ist, desto länger dauert die Aktion.
Die Rettung heißt: ArrayList
Ein kleines Beispielprogramm für ArrayList
Im Folgenden seht Ihr ein vollständiges und lauffähiges Programm, das mehr oder minder sinnvolle Operationen mit einer Array-List vollführt.
// WICHTIG: Einbinden der ArrayList aus der java-api:
import java.util.ArrayList;
public class ArrayListExample {
public static void main(String[] args) {
//anlegen einer ArrayListe
ArrayList liste = new ArrayList();
//fuellen der Liste mit Daten
liste.add("Apfel");
liste.add("Birne");
liste.add("Stuhl");
liste.add("Orange");
liste.add("Zitrone");
//Ausgeben der Liste
System.out.println(liste);
//Hmm - der gehoert hier nicht rein!
liste.remove("Stuhl");
// nochmal ausgeben
System.out.println(liste);
//testen ob Stuhl enthalten:
if (liste.contains ("Stuhl")){
System.out.println("Der Stuhl ist noch drin.");
}else{
System.out.println("Der Stuhl ist draußen.");
}
// testen ob Birne enthalten:
if (liste.contains ("Birne")){
System.out.println("Die Birne ist noch drin.");
}else{
System.out.println("Die Birne ist draußen.");
}
}
}
Die ArrayList bietet noch einige weitere Methoden:
int liste.size(); // liefert die Anzahl der Elemente in der Liste Object liste.get(int i); // liefert den Eintrag an Stelle i liste.remove(int i); // entfernt den Eintrag an Stelle i
Die Art und Weise, wie in diesem Beispiel die ArrayList benutzt wird hat nur einen kleinen Haken: Sie ist nicht typsicher. Das bedeutet, dass in der Liste alle Elemente
als Typ Object gespeichert werden. Daher muss man sie explizit umwandeln:
Die Zeile:
String obst = liste.get(2);
ergibt beim compilieren einen Fehler, da in der Liste "Objects" gespeichert sind und keine Strings.
Das bedeutet zwar, dass man in diese ArrayList nicht nur Strings hinein geben kann, sondern beliebige Typen. Das klingt erst einmal gut, weil man sich ja nicht nur auf Strings beschränken will - aber wie bekommen wir nun Strings heraus?
Generics
Eine Möglichkeit besteht darin, die sogenannten "Generics" zu benutzen. Keine Angst, auch wenn viele was anderes behaupten ist es eigentlich ganz einfach.
Wir müssen dazu in unserem Beispiel nur eine Zeile ändern:
//anlegen einer ArrayListe
ArrayList <String> liste = new ArrayList<String>();
Ab sofort erlaubt der Java Compiler uns nur noch Objekte vom Typ String in
der ArrayList zu speichern. Alles andere wird schon beim compilieren
verhindert, so dass wir gar keine falschen Typen mehr einfügen können.
Versucht es ruhig einmal selber:
Kopiert das ArrayList-Programm von oben zunächst ohne die Änderung. Dann erweitert es mit dem folgenden Kommando, um einen String für die Variable "obst" zu erhalten:
String obst = liste.get(2);
Casten
Eine andere Möglichkeit besteht darin, dem Java-Compiler zu sagen, dass Ihr euch sicher seid, keinen Typfehler zu machen und dass er den Typ einfach umwandeln soll. Das nennt man casten und es funktioniert so:
String obst = (String) liste.get(2);
Damit sagt ihr dem compiler: "Hey, ich weiß dass da etwas anderes als ein String rauskommt. Ich bin mir aber sicher, dass man das Element wie einen String behandeln kann!"
Das Problem an der Lösung ist, dass man unheimlich aufpassen muss, nicht versehentlich doch z.B. eine Rennschnecke im Array gespeichert zu haben, weil es dann einen Fehler zur Laufzeit des Programms gibt.
Ein Beispiel für komplexe Datentypen
Im Folgenden seht ihr drei Klassen, bei der in der ersten eine ArrayList zum Einsatz kommt, um die Teilnehmer an einem Praktikum zu verwalten.
/*
* DATEI: Praktikum.java
*/
import java.util.ArrayList;
class Praktikum {
String name;
ArrayList<Student> studenten; // ArrayList nur fuer Studenten
Praktikum(String aName) {
this.name = aName;
this.studenten = new ArrayList<Student>();
}
void addStudent(Student aStudent) {
studenten.add(aStudent);
}
//TODO: removeStudent -
// durch die studenten gehen und nach z.B. dem Namen suchen,
// etc.... ;)
double getAverageGrade() {
double average = 0; // initialisieren des Durchschnitts
int numberOfStudents = studenten.size();
if (numberOfStudents > 0) { // vermeiden der Division duch 0
for (int position = 0; position < numberOfStudents; position++) {
Student current = studenten.get(position);
average += current.grade;
}
average = average / numberOfStudents;
}
return average;
}
public String toString(){
int numberOfStudents = this.studenten.size();
String result= this.name+": \n";
result += "Teilnehmer : "+numberOfStudents +"\n";
result += "Durchschnittsnote: "+this.getAverageGrade()+"\n";
for (int position = 0; position < numberOfStudents; position++) {
Student current = studenten.get(position);
result += " "+position+".: "+current.name+" ("+current.grade+") \n";
}
return result;
}
}
/*
* DATEI: Student.java
*/
public class Student {
double grade;
String name;
Student(String aName,double aGrade){
this.grade=aGrade;
this.name=aName;
}
}
/*
* DATEI: TestPraktikum.java
*/
public class TestPraktikum {
public static void main(String[] args) {
Praktikum unixPraktikum = new Praktikum("UNIX-Praktikum");
Student florian = new Student("Florian",1.0);
Student maximilian = new Student("Maximilian",2.8);
unixPraktikum.addStudent(florian);
unixPraktikum.addStudent(maximilian);
System.out.println(unixPraktikum);
}
}
