Zum Inhalt springen

Innere Klassen und Iteratoren

Mit einer ArrayList funktioniert die for-each-Schleife, mit unserem eigenen DynamischesArray nicht. Warum? In diesem Kapitel finden wir es heraus – und lernen dabei, dass eine Klasse nicht immer eine eigene Datei braucht.

  • erklären, was der Compiler aus einer for-each-Schleife macht
  • eine eigene Klasse mit Iterable und Iterator für for-each nutzbar machen
  • die vier Arten von Klassen in Klassen unterscheiden: statisch geschachtelt, inner, lokal, anonym
  • erklären, welchen Typ var ableitet

Demo-Code: 26-iteratoren

⤓ demo-iteratoren.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 26-iteratoren wählen → OK → Trust Project. IntelliJ erkennt die pom.xml und lädt die Bibliotheken selbst herunter – das dauert beim ersten Mal einen Moment.

Enthält: pom.xml, DynamischesArray.java, IteratorDemo.java, LokaleKlassen.java, RollendesArray.java

Das Demo-Projekt ist ein Maven-Projekt. Es enthält das DynamischesArray aus dem Collection-Kapitel – schon mit allen Iteratoren aus diesem Kapitel – und das RollendesArray für die Übung.

DynamischesArray<String> namen = new DynamischesArray<>();
namen.hinzufuegen("Anna");
namen.hinzufuegen("Ben");
for (String name : namen) { // lässt sich nicht übersetzen
System.out.println(name);
}

IntelliJ unterstreicht namen rot: for-each geht nur über ein Array oder über etwas, das Iterable ist. Das Interface kennen wir aus der Hierarchie der ArrayList: ganz oben, mit der einzigen Fähigkeit „man kann über die Elemente laufen“.

Die for-each-Schleife ist eine Abkürzung. Der Compiler macht daraus:

Iterator<String> it = namen.iterator();
while (it.hasNext()) {
String name = it.next();
System.out.println(name);
}

Zwei Interfaces sind beteiligt:

Interface Methode sagt
Iterable<T> Iterator<T> iterator() „Ich kann dir einen Iterator geben.“
Iterator<T> boolean hasNext() „Es gibt noch ein Element.“
T next() „Hier ist das nächste.“ – und ein Schritt weiter

Ein Iterator ist wie ein Lesezeichen: Er merkt sich, wo er gerade steht. Jeder Aufruf von iterator() liefert ein neues Lesezeichen am Anfang. Zum Vertrag gehört außerdem: Ruft jemand next() auf, obwohl hasNext() false liefert, wirft der Iterator eine NoSuchElementException.

Damit for-each mit dem DynamischesArray funktioniert, braucht es also:

public class DynamischesArray<T> implements Iterable<T> {
// …
@Override
public Iterator<T> iterator() {
return …; // ein Objekt, das Iterator<T> implementiert
}
}

Bleibt die Frage: Wo schreiben wir die Klasse für den Iterator hin?

Naheliegend wäre eine Klasse ArrayIterator in einer eigenen Datei. Sie bekommt das Array im Konstruktor und zählt die Position hoch:

public class ArrayIterator<T> implements Iterator<T> {
private final DynamischesArray<T> array;
private int position;
// …
public boolean hasNext() {
return position < array.anzahl; // lässt sich nicht übersetzen: anzahl ist private
}
}

anzahl und daten sind private – zu Recht, das ist Kapselung. Wir könnten sie öffentlich machen, aber dann könnte jeder sie ändern. Der Iterator gehört eigentlich zum Array. Also schreiben wir ihn hinein.

Eine Klasse darf in einer anderen stehen, wie ein Feld oder eine Methode:

DynamischesArray.java (Ausschnitt)
private static class StatischerDurchlauf<E> implements Iterator<E> {
private final DynamischesArray<E> array;
private int position;
StatischerDurchlauf(DynamischesArray<E> array) {
this.array = array;
}
@Override
public boolean hasNext() {
return position < array.anzahl; // private – aber wir stehen in derselben Klasse
}
@Override
public E next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return array.get(position++);
}
}
public Iterator<T> statischerIterator() {
return new StatischerDurchlauf<>(this);
}
  • Weil sie innerhalb von DynamischesArray steht, darf sie auf dessen private-Felder zugreifen.
  • Weil sie private ist, sieht sie außerhalb niemand.
  • Weil sie static ist, gehört sie zur Klasse, nicht zu einem bestimmten Objekt. Welches Array sie durchläuft, müssen wir ihr deshalb mitgeben.

Du kennst so etwas schon: Map.Entry ist ein Interface, das in Map steht. Und der record Punkt im SetDemo aus dem Collection-Kapitel ist ebenfalls geschachtelt.

Lassen wir das static weg, wird daraus eine innere Klasse:

DynamischesArray.java (Ausschnitt)
private class Durchlauf implements Iterator<T> {
private int position;
@Override
public boolean hasNext() {
return position < anzahl; // das anzahl des äußeren Objekts
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return get(position++); // ausführlich: DynamischesArray.this.get(position++)
}
}
@Override
public Iterator<T> iterator() {
return new Durchlauf();
}

Kein Parameter, kein Feld array, kein eigener Typparameter: Ein Objekt einer inneren Klasse gehört immer zu einem Objekt der äußeren Klasse – zu dem, in dessen Methode es mit new erzeugt wurde. Deshalb kann es anzahl und get einfach benutzen. Ausgeschrieben hieße das DynamischesArray.this.anzahl.

Diese Form nimmt man für einen Iterator am häufigsten – auch die ArrayList im JDK macht es so.

Der Name Durchlauf wird genau an einer Stelle gebraucht. Dann geht es auch ohne:

DynamischesArray.java (Ausschnitt)
public Iterator<T> anonymerIterator() {
return new Iterator<>() {
private int position;
@Override
public boolean hasNext() {
return position < anzahl;
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return get(position++);
}
};
}

new Iterator<>() { … } heißt: „Eine Klasse, die Iterator implementiert, mit diesem Inhalt – und davon gleich ein Objekt.“ Klasse und Objekt entstehen in einem Ausdruck. Achte auf das Semikolon nach der schließenden Klammer: Der ganze Ausdruck ist Teil der return-Anweisung.

Eine Klasse darf sogar in einer Methode stehen:

DynamischesArray.java (Ausschnitt)
public Iterator<T> lokalerIterator() {
class LokalerDurchlauf implements Iterator<T> {
// … wie die innere Klasse
}
return new LokalerDurchlauf();
}

Sie hat einen Namen, gilt aber nur innerhalb dieser Methode – wie eine lokale Variable.

DynamischesArray.java mit allen vier Iteratoren
DynamischesArray.java
package de.drv.iteratoren;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Das dynamische Array aus dem Collection-Kapitel – jetzt {@link Iterable}, also mit
* for-each benutzbar. Zum Vergleich mit vier Iteratoren: statisch, inner, anonym, lokal.
*
* @param <T> der Typ der Elemente
*/
public class DynamischesArray<T> implements Iterable<T> {
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) {
if (index < 0 || index >= anzahl) {
throw new IndexOutOfBoundsException("Index " + index + " bei Größe " + anzahl);
}
return (T) daten[index];
}
public int groesse() {
return anzahl;
}
// ----- 1. Statische geschachtelte Klasse: braucht das Array als Parameter -----------
private static class StatischerDurchlauf<E> implements Iterator<E> {
private final DynamischesArray<E> array;
private int position;
StatischerDurchlauf(DynamischesArray<E> array) {
this.array = array;
}
@Override
public boolean hasNext() {
return position < array.anzahl; // private – aber wir stehen in derselben Klasse
}
@Override
public E next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return array.get(position++);
}
}
public Iterator<T> statischerIterator() {
return new StatischerDurchlauf<>(this);
}
// ----- 2. Innere Klasse: kennt ihr äußeres Objekt von selbst ------------------------
private class Durchlauf implements Iterator<T> {
private int position;
@Override
public boolean hasNext() {
return position < anzahl; // das anzahl des äußeren Objekts
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return get(position++); // ausführlich: DynamischesArray.this.get(position++)
}
}
/** Diese Methode verlangt Iterable – und mit ihr funktioniert for-each. */
@Override
public Iterator<T> iterator() {
return new Durchlauf();
}
// ----- 3. Anonyme Klasse: Klasse und Objekt in einem Ausdruck, ohne Namen -----------
public Iterator<T> anonymerIterator() {
return new Iterator<>() {
private int position;
@Override
public boolean hasNext() {
return position < anzahl;
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return get(position++);
}
};
}
// ----- 4. Lokale Klasse: steht in der Methode, die sie braucht ----------------------
public Iterator<T> lokalerIterator() {
class LokalerDurchlauf implements Iterator<T> {
private int position;
@Override
public boolean hasNext() {
return position < anzahl;
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return get(position++);
}
}
return new LokalerDurchlauf();
}
}
IteratorDemo.java
package de.drv.iteratoren;
import java.util.Iterator;
public class IteratorDemo {
public static void main(String[] args) {
DynamischesArray<String> namen = new DynamischesArray<>();
namen.hinzufuegen("Anna");
namen.hinzufuegen("Ben");
namen.hinzufuegen("Clara");
// for-each – möglich, weil DynamischesArray jetzt Iterable ist
for (String name : namen) {
System.out.print(name + " ");
}
System.out.println();
// Was der Compiler aus der for-each-Schleife macht
Iterator<String> it = namen.iterator();
while (it.hasNext()) {
String name = it.next();
System.out.print(name.toUpperCase() + " ");
}
System.out.println();
// Die anderen drei Iteratoren liefern dasselbe
zeige("statisch", namen.statischerIterator());
zeige("anonym", namen.anonymerIterator());
zeige("lokal", namen.lokalerIterator());
// Weil es ein Iterable ist, nehmen es auch Methoden des JDK an
System.out.println(String.join(", ", namen));
}
private static void zeige(String art, Iterator<String> it) {
System.out.print(art + ":");
while (it.hasNext()) {
System.out.print(" " + it.next());
}
System.out.println();
}
}
Terminal-Fenster
Anna Ben Clara
ANNA BEN CLARA
statisch: Anna Ben Clara
anonym: Anna Ben Clara
lokal: Anna Ben Clara
Anna, Ben, Clara

Die letzte Zeile: String.join nimmt nicht nur Arrays, sondern jedes Iterable aus Texten. Seit DynamischesArray den Vertrag erfüllt, passt es dort hinein – ohne dass String.join unsere Klasse kennt.

Art steht kennt das äußere Objekt? typisch für
statisch geschachtelt in der Klasse, mit static nein – man muss es mitgeben Hilfsklassen, die nur hierher gehören, z. B. Map.Entry
inner in der Klasse, ohne static ja Iteratoren und alles, was mit „seinem“ Objekt arbeitet
lokal in einer Methode ja, in einer Methode des Objekts selten – wenn eine Klasse nur in einer Methode gebraucht wird
anonym mitten in einem Ausdruck ja, in einer Methode des Objekts eine Implementierung, die genau einmal gebraucht wird

Schau nach dem Übersetzen in target\classes\de\drv\iteratoren:

DynamischesArray.class
DynamischesArray$StatischerDurchlauf.class
DynamischesArray$Durchlauf.class
DynamischesArray$1.class
DynamischesArray$1LokalerDurchlauf.class

Für die JVM gibt es keine Klassen in Klassen – jede wird zu einer eigenen .class-Datei. Der Name verrät, wo sie herkommt: hinter dem $ steht die geschachtelte Klasse, die anonyme bekommt eine Nummer.

Lokale Klassen zeigen gut, was var eigentlich tut. Aus dem Kapitel Variablen wissen wir: var lässt den Compiler den Typ aus der rechten Seite ableiten. Aber welchen Typ genau?

LokaleKlassen.java
package de.drv.iteratoren;
import java.util.Iterator;
/** Lokale Klassen und var: Welchen Typ leitet der Compiler ab? */
public class LokaleKlassen {
public static void main(String[] args) {
eigeneLokaleKlasse();
lokaleKlasseMitInterface();
anonymeKlasseMitVar();
}
/** 1. Eine lokale Klasse ohne Interface – sie gibt es nur in dieser Methode. */
static void eigeneLokaleKlasse() {
class Strichliste {
private int anzahl;
void strich() {
anzahl++;
}
@Override
public String toString() {
return "|".repeat(anzahl) + " (" + anzahl + ")";
}
}
Strichliste liste = new Strichliste(); // der Name ist hier bekannt …
var auchListe = new Strichliste(); // … und var leitet genau diesen Typ ab
for (int i = 0; i < 7; i++) {
liste.strich();
}
auchListe.strich();
System.out.println("liste: " + liste);
System.out.println("auchListe: " + auchListe);
}
/** 2. Eine lokale Klasse, die ein Interface implementiert – und eine Methode mehr hat. */
static void lokaleKlasseMitInterface() {
class Countdown implements Iterator<Integer> {
private int stand = 3;
@Override
public boolean hasNext() {
return stand > 0;
}
@Override
public Integer next() {
return stand--;
}
int rest() { // nicht im Interface
return stand;
}
}
Iterator<Integer> alsInterface = new Countdown();
alsInterface.next();
// alsInterface.rest(); – lässt sich nicht übersetzen: Iterator kennt rest() nicht
var alsKlasse = new Countdown(); // var: der Typ ist Countdown, nicht Iterator
alsKlasse.next();
System.out.println("Countdown, noch " + alsKlasse.rest());
}
/** 3. Eine anonyme Klasse mit eigenem Feld – erreichbar nur über var. */
static void anonymeKlasseMitVar() {
var zaehler = new Object() {
int stand;
};
zaehler.stand++;
zaehler.stand++;
System.out.println("zaehler.stand = " + zaehler.stand);
Object alsObject = zaehler;
// alsObject.stand++; – lässt sich nicht übersetzen: Object hat kein Feld stand
System.out.println("als Object: " + alsObject.getClass().getName());
}
}
Terminal-Fenster
liste: ||||||| (7)
auchListe: | (1)
Countdown, noch 2
zaehler.stand = 2
als Object: de.drv.iteratoren.LokaleKlassen$1
  1. Eine eigene lokale Klasse: Strichliste gibt es nur in dieser Methode. Innerhalb der Methode ist der Name bekannt – Strichliste liste und var auchListe bedeuten dasselbe. var leitet genau den Typ der rechten Seite ab.

  2. Eine lokale Klasse mit Interface: Countdown implementiert Iterator und hat eine Methode mehr, rest(). Hier macht es einen Unterschied, wie die Variable deklariert ist:

    • Iterator<Integer> alsInterface – wir sehen das Objekt durch die Brille des Interfaces. rest() gibt es dort nicht.
    • var alsKlasse – der Typ ist Countdown, nicht Iterator. rest() geht.

    var nimmt also immer den genauen Typ der rechten Seite – nie ein Interface, das man vielleicht gemeint hat. Wer gegen ein Interface programmieren will, schreibt es hin: List<String> namen = new ArrayList<>(); ist etwas anderes als var namen = new ArrayList<String>();.

  3. Eine anonyme Klasse mit Feld: new Object() { int stand; } ist eine Klasse ohne Namen. Ohne var gäbe es keinen Typ, den man links hinschreiben könnte – mit Object käme man an stand nicht heran. Nur var kann den namenlosen Typ festhalten. Eine Kuriosität, die man selten braucht – aber sie zeigt deutlich, dass var den Typ ableitet und nicht etwa „irgendein Typ“ bedeutet.

Im Demo-Projekt liegt das RollendesArray aus dem Collection-Kapitel. Es soll mit for-each funktionieren – vom ältesten zum neuesten Element.

  1. Iterable: Lass RollendesArray<T> das Interface Iterable<T> implementieren und schreibe den Iterator als innere Klasse. Probiere es in einem kleinen Hauptprogramm mit for-each aus.

  2. Der Vertrag: Ein Aufruf von next() ohne weiteres Element wirft eine NoSuchElementException. Lege dann diese Testklasse unter src\test\java\de\drv\iteratoren an und lass sie laufen:

    RollendesArrayIteratorTest.java
    RollendesArrayIteratorTest.java
    package de.drv.iteratoren;
    import static org.junit.jupiter.api.Assertions.assertEquals;
    import static org.junit.jupiter.api.Assertions.assertFalse;
    import static org.junit.jupiter.api.Assertions.assertThrows;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.NoSuchElementException;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    class RollendesArrayIteratorTest {
    private static RollendesArray<String> mit(String... werte) {
    RollendesArray<String> array = new RollendesArray<>(3);
    for (String wert : werte) {
    array.hinzufuegen(wert);
    }
    return array;
    }
    /** Sammelt mit for-each alles ein, was das Array liefert. */
    private static List<String> durchlaufe(RollendesArray<String> array) {
    List<String> gesehen = new ArrayList<>();
    for (String wert : array) {
    gesehen.add(wert);
    }
    return gesehen;
    }
    @Test
    @DisplayName("for-each liefert die Elemente vom ältesten zum neuesten")
    void foreach() {
    assertEquals(List.of("A", "B"), durchlaufe(mit("A", "B")));
    }
    @Test
    @DisplayName("Nach dem Rollen liefert for-each nur noch die neuesten")
    void nachDemRollen() {
    assertEquals(List.of("C", "D", "E"), durchlaufe(mit("A", "B", "C", "D", "E")));
    }
    @Test
    @DisplayName("Ein leeres Array liefert nichts")
    void leer() {
    assertFalse(mit().iterator().hasNext());
    assertEquals(List.of(), durchlaufe(mit()));
    }
    @Test
    @DisplayName("next ohne weiteres Element wirft eine NoSuchElementException")
    void zuWeit() {
    Iterator<String> it = mit("A").iterator();
    it.next();
    assertThrows(NoSuchElementException.class, () -> it.next());
    }
    @Test
    @DisplayName("Zwei Iteratoren laufen unabhängig voneinander")
    void unabhaengig() {
    RollendesArray<String> array = mit("A", "B");
    Iterator<String> erster = array.iterator();
    Iterator<String> zweiter = array.iterator();
    erster.next();
    assertEquals("B", erster.next());
    assertEquals("A", zweiter.next());
    }
    @Test
    @DisplayName("Ein RollendesArray passt überall, wo das JDK ein Iterable nimmt")
    void imJdk() {
    assertEquals("C, D, E", String.join(", ", mit("A", "B", "C", "D", "E")));
    }
    }

    assertThrows mit () -> it.next() kennst du aus dem Kapitel Exceptions – was genau dieses -> ist, klärt das nächste Kapitel.

  3. Rückwärts: Eine Methode rueckwaerts() liefert ein Iterable<T>, das vom neuesten zum ältesten Element läuft – sodass for (String s : array.rueckwaerts()) funktioniert. Schreibe es mit anonymen Klassen. Dazu gibt es diese Tests:

    RueckwaertsTest.java
    RueckwaertsTest.java
    package de.drv.iteratoren;
    import static org.junit.jupiter.api.Assertions.assertEquals;
    import java.util.ArrayList;
    import java.util.List;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    class RueckwaertsTest {
    @Test
    @DisplayName("rueckwaerts liefert die Elemente vom neuesten zum ältesten")
    void rueckwaerts() {
    RollendesArray<String> array = new RollendesArray<>(3);
    for (String wert : new String[] {"A", "B", "C", "D"}) {
    array.hinzufuegen(wert);
    }
    List<String> gesehen = new ArrayList<>();
    for (String wert : array.rueckwaerts()) {
    gesehen.add(wert);
    }
    assertEquals(List.of("D", "C", "B"), gesehen);
    }
    @Test
    @DisplayName("Vorwärts bleibt es dabei")
    void vorwaerts() {
    RollendesArray<String> array = new RollendesArray<>(3);
    array.hinzufuegen("A");
    array.hinzufuegen("B");
    assertEquals("A, B", String.join(", ", array));
    assertEquals("B, A", String.join(", ", array.rueckwaerts()));
    }
    }
  4. Für Schnelle: Eine ganz eigene Klasse Bereich für einen Zahlenbereich, sodass for (int zahl : new Bereich(1, 5)) die Zahlen 1 bis 5 liefert. Welches T hat das Iterable – und warum steht in der Schleife trotzdem int?

Lösung
  • Durchlauf ist eine innere Klasse: Sie benutzt anzahl und get des Arrays, zu dem sie gehört. Weil get(0) immer das älteste Element liefert, stimmt die Reihenfolge auch nach dem Rollen von selbst – der Iterator muss vom Rollen nichts wissen.
  • rueckwaerts() braucht zwei anonyme Klassen ineinander: ein Iterable, dessen iterator() einen Iterator liefert. Jeder Aufruf von iterator() beginnt wieder beim neuesten Element.

Zwei Dinge, die im Vertrag stehen, aber nicht in der Übung:

  • Iterator hat noch eine Methode remove(). Sie ist eine default-Methode und wirft eine UnsupportedOperationException – es sei denn, man überschreibt sie. Wieder unser Bekannter aus dem Interface-Kapitel.
  • Ändert jemand das Array, während ein Iterator darüber läuft, liefert unser Iterator Unsinn. Die ArrayList merkt so etwas und wirft eine ConcurrentModificationException.
RollendesArray.java
package de.drv.iteratoren;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Ein Array fester Größe, das immer die neuesten Elemente behält: Ist es voll, fällt
* beim Hinzufügen das älteste heraus.
*
* <p>Iterable: for-each liefert die Elemente vom ältesten zum neuesten.
*
* @param <T> der Typ der Elemente
*/
public class RollendesArray<T> implements Iterable<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;
}
/** Stufe 1 und 2: eine innere Klasse – sie kennt daten und anzahl ihres Arrays. */
private class Durchlauf implements Iterator<T> {
private int position;
@Override
public boolean hasNext() {
return position < anzahl;
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException("Kein weiteres Element");
}
return get(position++);
}
}
@Override
public Iterator<T> iterator() {
return new Durchlauf();
}
/** Stufe 3: vom neuesten zum ältesten – ein anonymes Iterable mit einem anonymen Iterator. */
public Iterable<T> rueckwaerts() {
return new Iterable<>() {
@Override
public Iterator<T> iterator() {
return new Iterator<>() {
private int position = anzahl - 1;
@Override
public boolean hasNext() {
return position >= 0;
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException("Kein weiteres Element");
}
return get(position--);
}
};
}
};
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOf(daten, anzahl));
}
}
Lösung
Terminal-Fenster
1 2 3 4 5
1 + 2 + … + 100 = 5050

Bereich ist ein Iterable<Integer> – für T darf ja nur eine Klasse stehen. In der Schleife steht trotzdem int, weil Java jedes Integer beim Herausholen auspackt: Autoboxing, genauer Unboxing. Ein Bereich(5, 1) liefert nichts, denn schon das erste hasNext() ist false.

Bereich.java
package de.drv.iteratoren;
import java.util.Iterator;
import java.util.NoSuchElementException;
/** Stufe 4: ein Zahlenbereich von – bis (einschließlich), mit for-each zu durchlaufen. */
public class Bereich implements Iterable<Integer> {
private final int von;
private final int bis;
public Bereich(int von, int bis) {
this.von = von;
this.bis = bis;
}
@Override
public Iterator<Integer> iterator() {
return new Iterator<>() {
private int naechste = von;
@Override
public boolean hasNext() {
return naechste <= bis;
}
@Override
public Integer next() {
if (!hasNext()) {
throw new NoSuchElementException("Kein weiteres Element");
}
return naechste++;
}
};
}
public static void main(String[] args) {
for (int zahl : new Bereich(1, 5)) {
System.out.print(zahl + " ");
}
System.out.println();
int summe = 0;
for (int zahl : new Bereich(1, 100)) {
summe += zahl;
}
System.out.println("1 + 2 + … + 100 = " + summe);
for (int zahl : new Bereich(5, 1)) {
System.out.println("Das erscheint nie: " + zahl);
}
}
}