Ein dynamisches Array
Arrays haben eine Schwäche, über die wir in Woche 1 bei der Bank und bei Wordle gestolpert sind: Ihre Länge steht beim Anlegen fest. In diesem Kapitel bauen wir ein Array, das mitwächst – und setzen dabei das Wissen aus dem letzten Kapitel ein.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- erklären, warum ein Array nicht wachsen kann und wie man es trotzdem vergrößert
- eine Klasse schreiben, die ein Array intern verwaltet
- diese Klasse mit einem Typparameter für jeden Typ nutzbar machen
- erklären, was
ArrayListim Inneren tut - selbst eine Sammlung mit eigenen Regeln entwerfen
Demo-Code: 19-dynamisches-array
⤓ demo-array.zip herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 19-dynamisches-array wählen → OK → Trust Project. Zeigt IntelliJ oben Project JDK is not defined: auf Setup SDK klicken und das JDK 21 wählen.
Enthält: FesteLaenge.java, DynamischesIntArray.java, DynamischesArray.java, ArrayDemo.java, Pruefung.java
Das Problem: feste Länge
Abschnitt betitelt „Das Problem: feste Länge“package de.drv.array;
import java.util.Arrays;
public class FesteLaenge {
public static void main(String[] args) { int[] zahlen = {3, 1, 4}; System.out.println(Arrays.toString(zahlen));
// zahlen[3] = 1; // ArrayIndexOutOfBoundsException – das Array hat nur 3 Plätze
// Größer machen geht nicht – nur ein neues, größeres Array mit denselben Werten int[] groesser = Arrays.copyOf(zahlen, 6); groesser[3] = 1; System.out.println(Arrays.toString(groesser));
zahlen = groesser; // die Variable zeigt jetzt auf das neue Array System.out.println(zahlen.length); }
}[3, 1, 4][3, 1, 4, 1, 0, 0]6- Ein Array kann nicht wachsen. Es gibt kein „Redim“ und kein „füge hinten an“.
Arrays.copyOf(array, neueLaenge)legt ein neues Array an und kopiert die Werte hinein. Die freien Plätze bekommen den Standardwert – beiintdie0.- Danach zeigt die Variable
zahlenauf das neue Array. Das alte räumt der Garbage Collector weg (siehe Referenzen).
Das ist umständlich: Wer ein Array füllt, muss selbst mitzählen, wie viele Plätze belegt sind, und rechtzeitig umkopieren. Diese Arbeit verpacken wir in eine Klasse.
Ein int-Array, das mitwächst
Abschnitt betitelt „Ein int-Array, das mitwächst“package de.drv.array;
import java.util.Arrays;
/** Ein int-Array, das mitwächst. */public class DynamischesIntArray {
private int[] daten = new int[4]; private int anzahl;
public void hinzufuegen(int wert) { if (anzahl == daten.length) { daten = Arrays.copyOf(daten, daten.length * 2); } daten[anzahl] = wert; anzahl++; }
public int get(int index) { if (index < 0 || index >= anzahl) { throw new IndexOutOfBoundsException("Index " + index + " bei Größe " + anzahl); } return daten[index]; }
public int groesse() { return anzahl; }
}- Die Klasse hat zwei Größen:
daten.lengthist der Platz, der da ist (die Kapazität),anzahldie Zahl der belegten Plätze. Von außen ist nuranzahlzu sehen – das ist diegroesse(). - Ist das Array voll, wird es verdoppelt. So muss nur selten umkopiert werden: Für 1000 Werte achtmal, nicht 996-mal.
getprüft den Index selbst. Ohne die Prüfung würdeget(5)bei drei Werten einfach die0von einem freien Platz liefern.
DynamischesIntArray zahlen = new DynamischesIntArray();for (int i = 1; i <= 10; i++) { zahlen.hinzufuegen(i * i);}System.out.println(zahlen.groesse() + " Quadratzahlen, die letzte: " + zahlen.get(9));10 Quadratzahlen, die letzte: 100Und für double? Für String?
Abschnitt betitelt „Und für double? Für String?“Für ein dynamisches double-Array müssten wir die Klasse kopieren und jedes
int, das einen Wert meint, durch double ersetzen. Für String noch
einmal, für Kunde noch einmal. Dreimal derselbe Code mit einem anderen Typ –
das ist genau der Fall für einen Typparameter:
public class DynamischesArray<T> {
// new T[4] geht nicht – deshalb ein Object-Array und ein Cast in get private Object[] daten = new Object[4]; private int anzahl;
public void hinzufuegen(T wert) { if (anzahl == daten.length) { daten = Arrays.copyOf(daten, daten.length * 2); } daten[anzahl] = wert; anzahl++; }
@SuppressWarnings("unchecked") public T get(int index) { pruefeIndex(index); return (T) daten[index]; }
// …}Fast alles ist wie beim int-Array – mit einer Ausnahme: Innen steht ein
Object[], kein T[].
new T[4]lässt sich nicht übersetzen. Erinnere dich an den Hinweis aus dem letzten Kapitel: Zur Laufzeit gibt es keinTmehr. Ein Array muss aber beim Anlegen wissen, welchen Typ es hat.- Also speichern wir in einem
Object[]und casten beim Herausholen aufT. Der Cast ist sicher, weilhinzufuegennur einTannimmt – es kann gar nichts anderes im Array liegen. - Prüfen kann der Compiler das nicht. Er warnt deshalb vor einem unchecked
cast. Mit
@SuppressWarnings("unchecked")sagen wir ihm: Wir haben es geprüft.
Der Cast steht jetzt an einer Stelle, in der Klasse – und nicht mehr bei jedem, der sie benutzt:
DynamischesArray<String> namen = new DynamischesArray<>();namen.hinzufuegen("Anna");namen.hinzufuegen("Ben");namen.hinzufuegen("Clara");String erster = namen.get(0); // kein Cast nötigUnd int?
Abschnitt betitelt „Und int?“DynamischesArray<int> geht nicht – für T sind nur Klassen erlaubt. Mit der
Wrapper-Klasse Integer klappt es, und Autoboxing nimmt uns die Umwandlung ab:
DynamischesArray<Integer> werte = new DynamischesArray<>();werte.hinzufuegen(42); // Autoboxing: aus int wird Integerint wert = werte.get(0); // Unboxing: aus Integer wird intBequem – aber nicht umsonst: Jeder Wert ist jetzt ein eigenes Objekt. Für
Millionen von Zahlen ist das DynamischesIntArray deutlich sparsamer. Und
Vorsicht beim Vergleichen zweier Integer mit == – siehe
Wrapper-Klassen.
Das gibt es schon
Abschnitt betitelt „Das gibt es schon“Unser DynamischesArray<T> gibt es im JDK – seit Java 1.2 und besser getestet,
als wir es je könnten:
import java.util.ArrayList;
ArrayList<String> namen = new ArrayList<>();namen.add("Anna");namen.add("Ben");String erster = namen.get(0);int anzahl = namen.size();unser DynamischesArray |
ArrayList |
|---|---|
hinzufuegen(wert) |
add(wert) |
get(index) |
get(index) |
groesse() |
size() |
set, entfernen, indexOf, enthaelt |
set, remove, indexOf, contains |
Und innen? Genau wie bei uns: ein Object[], ein Zähler und Arrays.copyOf,
wenn der Platz nicht reicht – nur wächst ArrayList jeweils um die Hälfte statt
um das Doppelte. In IntelliJ kannst du nachsehen: Strg+B auf ArrayList
öffnet den Quelltext aus dem JDK.
ArrayList ist aber nur eine von vielen fertigen Sammlungen im JDK. Was sie
verbindet, ist ein gemeinsamer Vertrag – darum geht es im nächsten Kapitel.
Übung 1: Das Array vervollständigen
Abschnitt betitelt „Übung 1: Das Array vervollständigen“Im Demo-Code stehen in DynamischesArray schon die Methoden für die Übung –
noch als Platzhalter, die eine UnsupportedOperationException werfen. Fülle sie
Stufe für Stufe aus. Nach jeder Stufe startest du das Programm Pruefung:
Stufe 1: set und istLeer ✗ abgebrochen: java.lang.UnsupportedOperationException: Übung, Stufe 1Stufe 2: entfernen ✗ abgebrochen: java.lang.UnsupportedOperationException: Übung, Stufe 2…-
Grundlage:
set(index, wert)ersetzt ein Element,istLeer()sagt, ob das Array leer ist. Ein ungültiger Index führt zu einerIndexOutOfBoundsException– dafür gibt es schonpruefeIndex. -
Entfernen:
entfernen(index)nimmt ein Element heraus und liefert es zurück. Alle Elemente dahinter rücken eine Stelle nach vorn. Tipp: Zeichne das Array auf Papier und schiebe die Werte mit dem Finger. -
Suchen:
indexOf(wert)liefert die erste Stelle, an der der Wert steht, sonst-1.enthaelt(wert)sagt, ob er vorkommt. Verglichen wird mitequals– nicht mit==. -
Für Schnelle:
einfuegen(index, wert)fügt einen Wert an einer beliebigen Stelle ein – die Elemente dahinter rücken auf. Und eintoString(), das das Array wie[Anna, Ben, Clara]ausgibt.
Pruefung.java
package de.drv.array;
/** Prüft die Methoden aus der Übung, Stufe für Stufe. */public class Pruefung {
public static void main(String[] args) { stufe1(); stufe2(); stufe3(); stufe4(); }
private static void stufe1() { System.out.println("Stufe 1: set und istLeer"); try { DynamischesArray<String> array = new DynamischesArray<>(); pruefe("ein neues Array ist leer", array.istLeer()); array.hinzufuegen("A"); array.hinzufuegen("B"); pruefe("nach hinzufuegen nicht mehr leer", !array.istLeer()); array.set(1, "X"); pruefe("set ersetzt das Element", "X".equals(array.get(1))); pruefe("set ändert die Größe nicht", array.groesse() == 2); try { array.set(2, "Y"); pruefe("set hinter dem Ende wirft eine IndexOutOfBoundsException", false); } catch (IndexOutOfBoundsException e) { pruefe("set hinter dem Ende wirft eine IndexOutOfBoundsException", true); } } catch (RuntimeException e) { abbruch(e); } }
private static void stufe2() { System.out.println("Stufe 2: entfernen"); try { DynamischesArray<String> array = mitInhalt("A", "B", "C", "D"); pruefe("entfernen liefert das entfernte Element", "B".equals(array.entfernen(1))); pruefe("danach ist das Array kleiner", array.groesse() == 3); pruefe("die folgenden Elemente rücken nach", "C".equals(array.get(1)) && "D".equals(array.get(2))); array.entfernen(2); pruefe("das letzte Element entfernen", array.groesse() == 2 && "C".equals(array.get(1))); try { array.entfernen(5); pruefe("entfernen hinter dem Ende wirft eine IndexOutOfBoundsException", false); } catch (IndexOutOfBoundsException e) { pruefe("entfernen hinter dem Ende wirft eine IndexOutOfBoundsException", true); } } catch (RuntimeException e) { abbruch(e); } }
private static void stufe3() { System.out.println("Stufe 3: indexOf und enthaelt"); try { DynamischesArray<String> array = mitInhalt("A", "B", "A"); pruefe("indexOf findet die erste Stelle", array.indexOf("A") == 0); pruefe("indexOf vergleicht mit equals", array.indexOf(new String("B")) == 1); pruefe("indexOf liefert -1, wenn es den Wert nicht gibt", array.indexOf("Z") == -1); pruefe("enthaelt", array.enthaelt("B") && !array.enthaelt("Z")); pruefe("entfernte Elemente werden nicht mehr gefunden", array.entfernen(1) != null && !array.enthaelt("B")); } catch (RuntimeException e) { abbruch(e); } }
private static void stufe4() { System.out.println("Stufe 4: einfuegen und toString"); try { DynamischesArray<String> array = mitInhalt("A", "C"); pruefe("toString", "[A, C]".equals(array.toString())); pruefe("toString eines leeren Arrays", "[]".equals(new DynamischesArray<String>().toString())); array.einfuegen(1, "B"); pruefe("einfuegen in der Mitte", "[A, B, C]".equals(array.toString())); array.einfuegen(0, "0"); array.einfuegen(4, "D"); pruefe("einfuegen am Anfang und am Ende", "[0, A, B, C, D]".equals(array.toString())); DynamischesArray<Integer> viele = new DynamischesArray<>(); for (int i = 0; i < 100; i++) { viele.einfuegen(0, i); } pruefe("100-mal am Anfang einfuegen", viele.groesse() == 100 && viele.get(0) == 99 && viele.get(99) == 0); } catch (RuntimeException e) { abbruch(e); } }
// String... (Varargs): beliebig viele Argumente, in der Methode ein String[] private static DynamischesArray<String> mitInhalt(String... werte) { DynamischesArray<String> array = new DynamischesArray<>(); for (String wert : werte) { array.hinzufuegen(wert); } return array; }
private static void pruefe(String beschreibung, boolean bestanden) { System.out.println((bestanden ? " ✓ " : " ✗ ") + beschreibung); }
private static void abbruch(RuntimeException e) { System.out.println(" ✗ abgebrochen: " + e); }
}Lösung
entfernenschiebt die Elemente von vorn nach hinten durch: Jedes übernimmt den Wert seines rechten Nachbarn. Danach wird der letzte Platz aufnullgesetzt – sonst hielte das Array ein Objekt fest, das gar nicht mehr dazugehört, und der Garbage Collector könnte es nicht wegräumen.einfuegenschiebt dagegen von hinten nach vorn. Andersherum würde jedes Element den Wert überschreiben, der als Nächstes verschoben werden soll. Für Platz sorgt ein Aufruf vonhinzufuegen– das spart eine zweite Kopie des Wachstums-Codes.indexOfvergleicht mitObjects.equals(a, b). Das ist wiea.equals(b), stürzt aber nicht ab, wennagleichnullist – und im Array darf auchnullstehen.
package de.drv.array;
import java.util.Arrays;import java.util.Objects;
/** * Ein Array, das mitwächst – für Elemente jedes Typs. * * @param <T> der Typ der Elemente */public class DynamischesArray<T> {
// new T[4] geht nicht – deshalb ein Object-Array und ein Cast in get private Object[] daten = new Object[4]; private int anzahl;
public void hinzufuegen(T wert) { if (anzahl == daten.length) { daten = Arrays.copyOf(daten, daten.length * 2); } daten[anzahl] = wert; anzahl++; }
@SuppressWarnings("unchecked") public T get(int index) { pruefeIndex(index); return (T) daten[index]; }
public int groesse() { return anzahl; }
private void pruefeIndex(int index) { if (index < 0 || index >= anzahl) { throw new IndexOutOfBoundsException("Index " + index + " bei Größe " + anzahl); } }
public void set(int index, T wert) { pruefeIndex(index); daten[index] = wert; }
public boolean istLeer() { return anzahl == 0; }
public T entfernen(int index) { T entfernt = get(index); // alle Elemente dahinter eine Stelle nach vorn for (int i = index; i < anzahl - 1; i++) { daten[i] = daten[i + 1]; } anzahl--; daten[anzahl] = null; // nichts festhalten, was nicht mehr dazugehört return entfernt; }
public int indexOf(T wert) { for (int i = 0; i < anzahl; i++) { if (Objects.equals(daten[i], wert)) { return i; } } return -1; }
public boolean enthaelt(T wert) { return indexOf(wert) >= 0; }
public void einfuegen(int index, T wert) { if (index < 0 || index > anzahl) { // am Ende einfügen ist erlaubt throw new IndexOutOfBoundsException("Index " + index + " bei Größe " + anzahl); } hinzufuegen(wert); // sorgt für Platz; der Wert landet vorläufig am Ende // alle Elemente ab index eine Stelle nach hinten for (int i = anzahl - 1; i > index; i--) { daten[i] = daten[i - 1]; } daten[index] = wert; }
@Override public String toString() { StringBuilder text = new StringBuilder("["); for (int i = 0; i < anzahl; i++) { if (i > 0) { text.append(", "); } text.append(daten[i]); } return text.append("]").toString(); }
}Übung 2: Ein rollendes Array
Abschnitt betitelt „Übung 2: Ein rollendes Array“Jetzt eine Sammlung mit anderen Regeln – von Grund auf selbst geschrieben. Ein rollendes Array hat eine feste Größe und behält immer die neuesten Elemente: Ist es voll, rutscht beim Hinzufügen alles eine Stelle nach vorn, das älteste fällt heraus, und das neue kommt ans Ende.
So etwas steckt überall, wo nur die letzten Einträge zählen: der Verlauf im Terminal, die letzten zehn Messwerte, die zuletzt geöffneten Dateien in IntelliJ.
package de.drv.array;
/** Ein Verlauf der letzten drei Eingaben – wie die Pfeiltaste nach oben im Terminal. */public class Verlauf {
public static void main(String[] args) { RollendesArray<String> verlauf = new RollendesArray<>(3); String[] eingaben = {"dir", "cd src", "javac Hallo.java", "java Hallo", "exit"}; for (String eingabe : eingaben) { verlauf.hinzufuegen(eingabe); System.out.println(verlauf); } }
}[dir][dir, cd src][dir, cd src, javac Hallo.java][cd src, javac Hallo.java, java Hallo][javac Hallo.java, java Hallo, exit]Schreibe die Klasse RollendesArray<T> im Projekt 19-dynamisches-array mit
diesen Methoden:
public RollendesArray(int kapazitaet) // feste Größepublic void hinzufuegen(T wert) // ist es voll, fällt das älteste herauspublic T get(int index) // 0 ist das älteste Elementpublic int groesse() // wie viele Elemente drin sindpublic int getKapazitaet() // wie viele hineinpassenpublic String toString() // [B, C, D]Lege die Klasse zuerst mit allen Methoden an – zur Not mit einem leeren
Rumpf oder return null;. Kopiere dann das Prüfprogramm in dein Projekt und
starte es nach jeder Stufe:
RollendesArrayPruefung.java
package de.drv.array;
/** Prüft ein RollendesArray, Stufe für Stufe. */public class RollendesArrayPruefung {
public static void main(String[] args) { stufe1(); stufe2(); stufe3(); }
private static void stufe1() { System.out.println("Stufe 1: Füllen und Lesen"); try { RollendesArray<String> array = new RollendesArray<>(3); pruefe("die Kapazität steht fest", array.getKapazitaet() == 3); pruefe("ein neues Array hat die Größe 0", array.groesse() == 0); array.hinzufuegen("A"); array.hinzufuegen("B"); pruefe("nach zwei Elementen ist die Größe 2", array.groesse() == 2); pruefe("get(0) ist das erste Element", "A".equals(array.get(0))); pruefe("get(1) ist das zweite Element", "B".equals(array.get(1))); array.hinzufuegen("C"); pruefe("jetzt ist es voll", array.groesse() == 3 && "C".equals(array.get(2))); } catch (RuntimeException e) { abbruch(e); } }
private static void stufe2() { System.out.println("Stufe 2: Rollen"); try { RollendesArray<String> array = new RollendesArray<>(3); array.hinzufuegen("A"); array.hinzufuegen("B"); array.hinzufuegen("C"); array.hinzufuegen("D"); pruefe("die Größe bleibt bei der Kapazität", array.groesse() == 3); pruefe("das älteste ist herausgefallen", "B".equals(array.get(0))); pruefe("das neue steht am Ende", "D".equals(array.get(2))); array.hinzufuegen("E"); pruefe("noch einmal rollen", "C".equals(array.get(0)) && "D".equals(array.get(1)) && "E".equals(array.get(2)));
RollendesArray<Integer> zahlen = new RollendesArray<>(5); for (int i = 1; i <= 1000; i++) { zahlen.hinzufuegen(i); } pruefe("nach 1000 Zahlen bleiben 996 bis 1000", zahlen.get(0) == 996 && zahlen.get(4) == 1000);
RollendesArray<String> eins = new RollendesArray<>(1); eins.hinzufuegen("X"); eins.hinzufuegen("Y"); pruefe("Kapazität 1: nur das neueste bleibt", eins.groesse() == 1 && "Y".equals(eins.get(0))); } catch (RuntimeException e) { abbruch(e); } }
private static void stufe3() { System.out.println("Stufe 3: Fehlerfälle und toString"); try { RollendesArray<String> array = new RollendesArray<>(3); array.hinzufuegen("A"); try { array.get(1); pruefe("get hinter dem letzten Element wirft eine IndexOutOfBoundsException", false); } catch (IndexOutOfBoundsException e) { pruefe("get hinter dem letzten Element wirft eine IndexOutOfBoundsException", true); } try { new RollendesArray<String>(0); pruefe("Kapazität 0 wirft eine IllegalArgumentException", false); } catch (IllegalArgumentException e) { pruefe("Kapazität 0 wirft eine IllegalArgumentException", true); } pruefe("toString", "[A]".equals(array.toString())); array.hinzufuegen("B"); array.hinzufuegen("C"); array.hinzufuegen("D"); pruefe("toString nach dem Rollen", "[B, C, D]".equals(array.toString())); } catch (RuntimeException e) { abbruch(e); } }
private static void pruefe(String beschreibung, boolean bestanden) { System.out.println((bestanden ? " ✓ " : " ✗ ") + beschreibung); }
private static void abbruch(RuntimeException e) { System.out.println(" ✗ abgebrochen: " + e); }
}-
Grundlage: Konstruktor,
hinzufuegen, solange Platz ist,get,groesseundgetKapazitaet. Wie beimDynamischesArrayliegen die Werte intern in einemObject[]– diesmal mit fester Länge. -
Rollen: Ist das Array voll, rutscht beim Hinzufügen alles eine Stelle nach vorn, und das neue Element kommt an den letzten Platz.
-
Fehlerfälle und
toString:getmit einem ungültigen Index wirft eineIndexOutOfBoundsException, eine Kapazität unter 1 im Konstruktor eineIllegalArgumentException.toString()liefert die Elemente vom ältesten zum neuesten. -
Für Schnelle: Bei einer Kapazität von einer Million verschiebt jedes
hinzufuegeneine Million Elemente. Baue die Klasse so um, dass beim Hinzufügen nichts verschoben wird – das Prüfprogramm muss danach weiterhin alles bestehen. Tipp: Merke dir, an welcher Stelle das älteste Element steht, und rechne mit%.
Lösung
Die einfache Fassung mit Verschieben. Das Array daten ist final: Die Größe
ändert sich nie, ein Arrays.copyOf zum Wachsen gibt es hier nicht.
package de.drv.array;
import java.util.Arrays;
/** * Ein Array fester Größe, das immer die neuesten Elemente behält: Ist es voll, fällt * beim Hinzufügen das älteste heraus. * * @param <T> der Typ der Elemente */public class RollendesArray<T> {
private final Object[] daten; private int anzahl;
public RollendesArray(int kapazitaet) { if (kapazitaet < 1) { throw new IllegalArgumentException("Die Kapazität muss mindestens 1 sein: " + kapazitaet); } daten = new Object[kapazitaet]; }
public void hinzufuegen(T wert) { if (anzahl == daten.length) { // voll: alle eine Stelle nach vorn, das älteste fällt heraus for (int i = 0; i < daten.length - 1; i++) { daten[i] = daten[i + 1]; } daten[daten.length - 1] = wert; } else { daten[anzahl] = wert; anzahl++; } }
/** Das Element an der Stelle {@code index}; 0 ist das älteste. */ @SuppressWarnings("unchecked") public T get(int index) { if (index < 0 || index >= anzahl) { throw new IndexOutOfBoundsException("Index " + index + " bei Größe " + anzahl); } return (T) daten[index]; }
public int groesse() { return anzahl; }
public int getKapazitaet() { return daten.length; }
@Override public String toString() { return Arrays.toString(Arrays.copyOf(daten, anzahl)); }
}Lösung
Die Fassung für Schnelle, ein Ringpuffer: Das Array wird gedanklich zu einem
Ring gebogen. anfang zeigt auf das älteste Element. Ist der Ring voll,
überschreibt das neue Element das älteste, und anfang rückt eine Stelle
weiter. Der Rest der Division mit % sorgt dafür, dass es nach dem letzten
Platz wieder bei 0 weitergeht.
Von außen sieht man keinen Unterschied – get(0) ist weiterhin das älteste
Element. Genau das zeigt das Prüfprogramm: Gleiches Verhalten, andere
Implementierung. Darum geht es im nächsten Kapitel.
package de.drv.array;
/** * Ein Array fester Größe, das immer die neuesten Elemente behält – als Ringpuffer: * Beim Hinzufügen wird nichts verschoben, nur der Anfang wandert weiter. * * @param <T> der Typ der Elemente */public class RollendesArray<T> {
private final Object[] daten; private int anfang; // Stelle des ältesten Elements private int anzahl;
public RollendesArray(int kapazitaet) { if (kapazitaet < 1) { throw new IllegalArgumentException("Die Kapazität muss mindestens 1 sein: " + kapazitaet); } daten = new Object[kapazitaet]; }
public void hinzufuegen(T wert) { if (anzahl == daten.length) { // voll: Das neue Element überschreibt das älteste, der Anfang rückt weiter daten[anfang] = wert; anfang = (anfang + 1) % daten.length; } else { daten[(anfang + anzahl) % daten.length] = wert; anzahl++; } }
/** Das Element an der Stelle {@code index}; 0 ist das älteste. */ @SuppressWarnings("unchecked") public T get(int index) { if (index < 0 || index >= anzahl) { throw new IndexOutOfBoundsException("Index " + index + " bei Größe " + anzahl); } return (T) daten[(anfang + index) % daten.length]; }
public int groesse() { return anzahl; }
public int getKapazitaet() { return daten.length; }
@Override public String toString() { StringBuilder text = new StringBuilder("["); for (int i = 0; i < anzahl; i++) { if (i > 0) { text.append(", "); } text.append(get(i)); } return text.append("]").toString(); }
}