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!

Java ArrayList

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.

java ArrayList Iterator

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?

Java ArrayList Features

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!

Hallo ich bin Kim und ich möchte ein großer Programmierer werden. Machst du mit?

Kommentare (26)

  • Antworte

    Kleiner Hinweis: Die spitzen Klammern fehlen (Generics).

    • Ja, das stimmt! Danke für den Hinweis und Entschuldigung wegen dem Fehler. Das korrigiere ich. Viele Grüße Kim

    • Hallo,
      danke sehr das Du Dir die Zeit nimmst und den Menschen hilfst Java besser zu verstehen , aber eine Frage habe ich da, wie kann ich ich den Inhalt eines mehrdimensionalen Arrays ausgeben, wenn ich diesen über ein Dialogfeld vorher eingeben muss.
      int Lager [][] = new int [5][10];
      Hier soll ich über eine Methode Werte einlesen , und auch ausgeben , ich verstehen einfach nicht wie das gehen soll und niemand kann mir das erklären.

      Danke für eine eventuelle Antwort

    • Hallo Henri, ein zweidimensionales Array kannst du dir als am besten als Schachbrett visualisieren. Der erste Index steht für die Zeile im Schachbrett und der zweite für die Spalte. D.h. wenn du beispielsweise den Wert aus der zweiten Zeile und dritte Spalten haben möchtest dann greifst du auf dieses Element mit Lager[1][2] (Indizierung beginnt bei 0) zu. Viele Grüße Kim

  • Antworte

    Super Beschreibung!!

    • Vielen Dank!

  • Antworte

    Hallo, das passt alles nicht so richtig für meinen Fall. Ich mochte die Ordinaten x in ein Feld eingeben im Rahmen einer Schleife . Wie kann ich das machen, dass der eingegebene Wert x weiß, dass er zur Laufvariablen i gehört. Es gibt hier leider keine Indizees als Ordnungsprinzip. Muss ich da schreiben x*i/i ? Der Wert x aber darf ja nicht verfälscht werden!

    • Hallo Karl, ich bin mir nicht sicher, ob ich deine Frage richtig verstehe. Aber nehmen wir an du hast in deiner Schleife folgende ArrayList eingelesen.

      deineListe = [0.5,0.7,1.1,1.6,2.3] (Also mit Hilfe der add Methode)

      Um über den Index (bei 0 bgeinnend) auf ein Element in der Liste zu zugreifen, gibt es die get Methode.

      Beispielsweise liefert dir der Aufruf deinListe.get(2) den Wert 1.1.

      Umgekehrt kannst du mit der Methode indexOf feststellen, welcher index zu einem Eintrag gehört.

      Beispielsweise liefert deineListe.indexOf(1.1) den Index 2.

      Neben der get Methode gibt es außerdem noch die set Methode mit der du Elemente zu einem index setzen kannst.

      Beispiel: Nach deineListe.set(2,8000) hat dein Liste die Gestalt [0.5,0.7,8000,1.6,2.3]

      Hilft das weiter?

      Viele Grüße
      Kim

  • Antworte

    „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.“

    Das ist so nicht korrekt und darf meiner Meinung nach nicht stehen gelassen werden. Das Inkrement findet im Schleifenrumpf statt, durch den Aufruf der next-Methode und dadurch ändert sich auch bei Erreichen des Listen-Endes der Wert der hasNext-Methode – welche nach wie vor die Bedingung für die for-Schleife ist und nicht das Inkrement. Auch gut daran zu sehen, wo es im Kopf der for-Schleife steht und das der Inkrement-Teil explizit weggelassen wird (aber das vorangehende Semikolon ihn trotzdem kennzeichnet).

    • Hallo Jöran, vielen Dank für das Aufmerksame lesen. Ich werde das nochmal prüfen und gegebenfalls korrigieren. Viele Grüße Kim

  • Antworte

    Hallo Kim,
    ich versuche folgende Methode zu entwickeln:
    Die Methode(M) konsumiert eine eine Liste(l) z.B [2, 5] und ein Zahl (n) z.B. 20.
    M soll zunächst prüfen, ob l bereits existiert, es also eine Liste [2, 5] bereits gibt.
    (Daher dachte ich erstelle zunächst eine Liste, die Listen enthält)
    Wenn ja: füge n der Liste hinzu: [ [2, 5], 20 ]
    Wenn nein: Erstelle Liste [2, 5] in Liste [ ] und füge n hinzu -> [ [2, 5], 20]

    Ich habe gerade erst mit Java begonnen und kriege es nicht gelöst. Kannst du mir einen Tipp geben? oder verwende ich die falschen Werkzeuge?

    Grüße, Sven

    • Hallo Sven, wenn ich das richtig verstehe geht es dir darum, dass in deiner Datenstruktur keine Elemente doppelt vorhanden sind. Richtig? Hierfür solltest du am besten Mengen (Sets) (http://openbook.rheinwerk-verlag.de/javainsel9/javainsel_13_005.htm#mj45263b87fd44c62f2cde668164897a93) verwenden. Sets haben von Haus aus die Eigenschaft, dass in diesen ein Element nicht mehrfach gespeichert werden kann. Des Weiteren ist es wichtig darauf zu achten, dass alle Elemente in deiner Liste den gleichen Typ haben. In deinem Beispiel [[2,5],20] besteht deine Liste aus einer weiteren Liste und einen einfachen Integer. Damit hat der Compiler ein Problem. Möglich wäre [[2,5],[20]],[2,5,20] oder [[2,5,20]] da dann alle Elemente in deiner Liste vom gleichen Typ sind. Hilft dir das weiter? Viele Grüße Kim

  • Antworte

    Hallo Kim,

    och bin aktuell dabei XML Files zu parsen und zu prüfen, ob in der XML angegebene Elemente (z.B. SequenceNumber) vollständig in einer Liste sind. Ich gebe dem Programm XMLs mit der SequenceNumber 100 bis 200. Das Programm prüft, ob die Nummer 100, 101, 102, … 199, 200 vorhanden sind. Fehlt etwa die Nummer 159, soll mir diese als Warnung ausgegeben werden.

    Vermutlich kann man dies mit einer Liste auswerten. Wie gehe ich am besten vor?

    Idee: den aktuellen Wert speichern, +1 rechnen, wenn Wert + 1 = nächster Wert weiter, wenn nicht ausgeben.
    –> counter = 145 +1 (146) | if counter == nächster wert .. usw usw.
    Wenn also 146 == 147 ergeben würde, dann weiß das Programm, dass die 146 fehlt und gibt sie aus.

    lg
    Toni

    • Hallo Toni, ja, finde deinen Lösungsansatz gut. So würde ich es denke ich auch machen. Viele Grüße Kim

  • Antworte

    Hi Kim,
    super erklärt, Danke !! das hat mir sehr geholfen !

    • Hi Bea, vielen Dank. Das freut mich sehr! Viele Grüße Kim

  • Antworte

    Sehr schöne Website. Danke für die Hilfe

    • Vielen Dank für dein Feedback!

  • Antworte

    Lese deinen Blog immer mal wieder zur schnellen Auffrischung während meines Studiums sehr gerne.
    Mach‘ weiter so, gibst dir echt viel Mühe, erklärst einfach, aber mit vernünftigem Background 😉

    • Ich danke dir für die Rückmeldung! Viele Grüße Kim

  • Antworte

    Hallo Kim,
    super Blog! Ich hätte zu diesem Thema noch eine Frage. Ist es möglich ein mehrdimensionales Array oder eine ArrayList dynamisch zu erstellen? Da ich die Größe des Arrays vorher noch nicht weiß und um unnötigen Speicherplatz zu verschwenden, möchte ich ein dynamisches Array erstellen. Kannst du mir hier vielleicht weiterhelfen?

    • Hallo Silvia, ja, das geht. Du musst eine verschachtelte ArrayList verwenden. D.h. eine ArrayList deren Listenelemente wiederum Listenelemente sind. Viele Grüße Kim

  • Antworte

    Hallo Kim,

    Dein Blog hilft mir wirklich sehr, daher frage ich mich ob es möglich wäre das du noch einen Artikel über Generics machst? Das wäre mega cool!

    LG aus Österreich =)

    • Hallo Lisa, vielen Dank für das Feedback. Einen Artikel über Generics habe ich schon länger im Kopf. Ich hoffe sehr, dass ich bald mal wieder dazu komme überhaupt etwas für den Blog zu schreiben. Viele Grüße Kim

  • Antworte

    geiler shit

    • Hi Paul, vielen Dank! Viele Grüße Kim

Hinterlasse ein Kommentar