Zum Inhalt springen

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.

  • 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 ArrayList im Inneren tut
  • selbst eine Sammlung mit eigenen Regeln entwerfen

Demo-Code: 19-dynamisches-array

⤓ demo-array.zip herunterladen

Der 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

FesteLaenge.java
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);
}
}
Terminal-Fenster
[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 – bei int die 0.
  • Danach zeigt die Variable zahlen auf 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.

DynamischesIntArray.java
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.length ist der Platz, der da ist (die Kapazität), anzahl die Zahl der belegten Plätze. Von außen ist nur anzahl zu sehen – das ist die groesse().
  • Ist das Array voll, wird es verdoppelt. So muss nur selten umkopiert werden: Für 1000 Werte achtmal, nicht 996-mal.
  • get prüft den Index selbst. Ohne die Prüfung würde get(5) bei drei Werten einfach die 0 von 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));
Terminal-Fenster
10 Quadratzahlen, die letzte: 100

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:

DynamischesArray.java (Ausschnitt)
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 kein T mehr. Ein Array muss aber beim Anlegen wissen, welchen Typ es hat.
  • Also speichern wir in einem Object[] und casten beim Herausholen auf T. Der Cast ist sicher, weil hinzufuegen nur ein T annimmt – 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ötig

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 Integer
int wert = werte.get(0); // Unboxing: aus Integer wird int

Bequem – 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.

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.

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:

Terminal-Fenster
Stufe 1: set und istLeer
✗ abgebrochen: java.lang.UnsupportedOperationException: Übung, Stufe 1
Stufe 2: entfernen
✗ abgebrochen: java.lang.UnsupportedOperationException: Übung, Stufe 2
…
  1. Grundlage: set(index, wert) ersetzt ein Element, istLeer() sagt, ob das Array leer ist. Ein ungültiger Index führt zu einer IndexOutOfBoundsException – dafür gibt es schon pruefeIndex.

  2. 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.

  3. Suchen: indexOf(wert) liefert die erste Stelle, an der der Wert steht, sonst -1. enthaelt(wert) sagt, ob er vorkommt. Verglichen wird mit equals – nicht mit ==.

  4. Für Schnelle: einfuegen(index, wert) fügt einen Wert an einer beliebigen Stelle ein – die Elemente dahinter rücken auf. Und ein toString(), das das Array wie [Anna, Ben, Clara] ausgibt.

Pruefung.java
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
  • entfernen schiebt die Elemente von vorn nach hinten durch: Jedes übernimmt den Wert seines rechten Nachbarn. Danach wird der letzte Platz auf null gesetzt – sonst hielte das Array ein Objekt fest, das gar nicht mehr dazugehört, und der Garbage Collector könnte es nicht wegräumen.
  • einfuegen schiebt 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 von hinzufuegen – das spart eine zweite Kopie des Wachstums-Codes.
  • indexOf vergleicht mit Objects.equals(a, b). Das ist wie a.equals(b), stürzt aber nicht ab, wenn a gleich null ist – und im Array darf auch null stehen.
DynamischesArray.java
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();
}
}

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.

Verlauf.java
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);
}
}
}
Terminal-Fenster
[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öße
public void hinzufuegen(T wert) // ist es voll, fällt das älteste heraus
public T get(int index) // 0 ist das älteste Element
public int groesse() // wie viele Elemente drin sind
public int getKapazitaet() // wie viele hineinpassen
public 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
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);
}
}
  1. Grundlage: Konstruktor, hinzufuegen, solange Platz ist, get, groesse und getKapazitaet. Wie beim DynamischesArray liegen die Werte intern in einem Object[] – diesmal mit fester Länge.

  2. Rollen: Ist das Array voll, rutscht beim Hinzufügen alles eine Stelle nach vorn, und das neue Element kommt an den letzten Platz.

  3. Fehlerfälle und toString: get mit einem ungültigen Index wirft eine IndexOutOfBoundsException, eine Kapazität unter 1 im Konstruktor eine IllegalArgumentException. toString() liefert die Elemente vom ältesten zum neuesten.

  4. Für Schnelle: Bei einer Kapazität von einer Million verschiebt jedes hinzufuegen eine 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.

RollendesArray.java
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.

RollendesArray.java
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();
}
}