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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- erklären, was der Compiler aus einer for-each-Schleife macht
- eine eigene Klasse mit
IterableundIteratorfür for-each nutzbar machen - die vier Arten von Klassen in Klassen unterscheiden: statisch geschachtelt, inner, lokal, anonym
- erklären, welchen Typ
varableitet
Demo-Code: 26-iteratoren
⤓ demo-iteratoren.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 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.
Das Problem
Abschnitt betitelt „Das Problem“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“.
Was for-each eigentlich ist
Abschnitt betitelt „Was for-each eigentlich ist“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?
Erster Versuch: eine eigene Datei
Abschnitt betitelt „Erster Versuch: eine eigene Datei“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.
1. Statische geschachtelte Klasse
Abschnitt betitelt „1. Statische geschachtelte Klasse“Eine Klasse darf in einer anderen stehen, wie ein Feld oder eine Methode:
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
DynamischesArraysteht, darf sie auf dessenprivate-Felder zugreifen. - Weil sie
privateist, sieht sie außerhalb niemand. - Weil sie
staticist, 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.
2. Innere Klasse
Abschnitt betitelt „2. Innere Klasse“Lassen wir das static weg, wird daraus eine innere Klasse:
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++) }}
@Overridepublic 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.
3. Anonyme Klasse
Abschnitt betitelt „3. Anonyme Klasse“Der Name Durchlauf wird genau an einer Stelle gebraucht. Dann geht es auch
ohne:
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.
4. Lokale Klasse
Abschnitt betitelt „4. Lokale Klasse“Eine Klasse darf sogar in einer Methode stehen:
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
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(); }
}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(); }
}Anna Ben ClaraANNA BEN CLARAstatisch: Anna Ben Claraanonym: Anna Ben Claralokal: Anna Ben ClaraAnna, Ben, ClaraDie 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.
Die vier Arten im Überblick
Abschnitt betitelt „Die vier Arten im Überblick“| 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 |
Was der Compiler daraus macht
Abschnitt betitelt „Was der Compiler daraus macht“Schau nach dem Übersetzen in target\classes\de\drv\iteratoren:
DynamischesArray.classDynamischesArray$StatischerDurchlauf.classDynamischesArray$Durchlauf.classDynamischesArray$1.classDynamischesArray$1LokalerDurchlauf.classFü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 und var
Abschnitt betitelt „Lokale Klassen und var“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?
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()); }
}liste: ||||||| (7)auchListe: | (1)Countdown, noch 2zaehler.stand = 2als Object: de.drv.iteratoren.LokaleKlassen$1-
Eine eigene lokale Klasse:
Strichlistegibt es nur in dieser Methode. Innerhalb der Methode ist der Name bekannt –Strichliste listeundvar auchListebedeuten dasselbe.varleitet genau den Typ der rechten Seite ab. -
Eine lokale Klasse mit Interface:
CountdownimplementiertIteratorund 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 istCountdown, nichtIterator.rest()geht.
varnimmt 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 alsvar namen = new ArrayList<String>();. -
Eine anonyme Klasse mit Feld:
new Object() { int stand; }ist eine Klasse ohne Namen. Ohnevargäbe es keinen Typ, den man links hinschreiben könnte – mitObjectkäme man anstandnicht heran. Nurvarkann den namenlosen Typ festhalten. Eine Kuriosität, die man selten braucht – aber sie zeigt deutlich, dassvarden Typ ableitet und nicht etwa „irgendein Typ“ bedeutet.
Übung: Das rollende Array wird iterierbar
Abschnitt betitelt „Übung: Das rollende Array wird iterierbar“Im Demo-Projekt liegt das RollendesArray aus dem Collection-Kapitel. Es soll
mit for-each funktionieren – vom ältesten zum neuesten Element.
-
Iterable: Lass
RollendesArray<T>das InterfaceIterable<T>implementieren und schreibe den Iterator als innere Klasse. Probiere es in einem kleinen Hauptprogramm mit for-each aus. -
Der Vertrag: Ein Aufruf von
next()ohne weiteres Element wirft eineNoSuchElementException. Lege dann diese Testklasse untersrc\test\java\de\drv\iteratorenan 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")));}}assertThrowsmit() -> it.next()kennst du aus dem Kapitel Exceptions – was genau dieses->ist, klärt das nächste Kapitel. -
Rückwärts: Eine Methode
rueckwaerts()liefert einIterable<T>, das vom neuesten zum ältesten Element läuft – sodassfor (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()));}} -
Für Schnelle: Eine ganz eigene Klasse
Bereichfür einen Zahlenbereich, sodassfor (int zahl : new Bereich(1, 5))die Zahlen 1 bis 5 liefert. WelchesThat dasIterable– und warum steht in der Schleife trotzdemint?
Lösung
Durchlaufist eine innere Klasse: Sie benutztanzahlundgetdes Arrays, zu dem sie gehört. Weilget(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: einIterable, desseniterator()einenIteratorliefert. Jeder Aufruf voniterator()beginnt wieder beim neuesten Element.
Zwei Dinge, die im Vertrag stehen, aber nicht in der Übung:
Iteratorhat noch eine Methoderemove(). Sie ist eine default-Methode und wirft eineUnsupportedOperationException– 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
ArrayListmerkt so etwas und wirft eineConcurrentModificationException.
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
1 2 3 4 51 + 2 + … + 100 = 5050Bereich 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.
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); } }
}