Update of exercises

Abstrakte_Klassen_001/readme.md

@@ -0,0 +1,28 @@
+# Abstrakte Klassen
+## Lernziel
+
+
+
+Eine abstrakte Klasse einsetzen, um eine einheitliche Schnittstelle für unterschiedliche Klassen anzubieten.
+
+## Aufgabe
+
+Im Paket [pr2.interfaces.abstrakte_klassen_e](../sources/src/main/java/pr2/interfaces/abstrakte_klassen_e/) finden Sie Klassen, welche geometrische Figuren repräsentieren.
+
+Betrachten Sie die vorhandenen Klassen `Dreieck`, `Kreis` und `Geometer` und finden Sie Gemeinsamkeiten und Unterschiede. Lassen Sie das Programm laufen und notieren Sie sich die Ausgabe.
+
+Führen Sie eine neue _abstrakte_ Klasse `Figur` ein und vereinfachen Sie mit dieser Klasse das vorhandene Programm. Lassen Sie das Programm erneut laufen und vergleichen Sie die Ausgabe mit der vorher notierten.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Abstrakte_Klassen_002/readme.md

@@ -0,0 +1,31 @@
+# Abstrakte Klasse
+## Lernziel
+
+
+
+Abstrakte Klasse verwenden.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.interfaces.abstrakt_form](../sources/src/main/java/pr2/interfaces/abstrakt_form/).
+
+Schreiben Sie bitte eine abstrakte Klasse `Form` mit den folgenden abstrakten Methoden:
+
+  * `flaeche()` liefert die Fläche der Form als Gleitkommazahl mit doppelter Genauigkeit zurück
+  * `umfang()` liefert den Umfang der Form als Gleitkommazahl mit doppelter Genauigkeit zurück
+
+Fügen Sie außerdem noch zwei Attribute für die x- und y-Position der Form hinzu und schreiben Sie einen entsprechenden Konstruktor. Wählen Sie die Sichtbarkeiten der Attribute so, dass Subklassen sie lesen und schreiben können.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Einfuehrung_001/readme.md

@@ -0,0 +1,28 @@
+# Java-Coding-Standard anwenden
+## Lernziel
+
+
+
+Java-Code korrekt entsprechend dem [Coding-Standard von Oracle](http://www.oracle.com/technetwork/java/codeconventions-150003.pdf) formatieren.
+
+## Aufgabe
+
+Im Paket [pr2.intro.coding_standard](../sources/src/main/java/pr2/intro/coding_standard/) finden Sie eine Klasse `CodingStandard`. Compilieren Sie die Datei `CodingStandard.java` und stellen Sie so sicher, dass es sich um eine syntaktisch korrekte Java-Klasse handelt.
+
+Formatieren Sie `CodingStandard` so um, dass sie dem in der Vorlesung vorgestellten Coding-Standard entspricht.
+
+Prüfen Sie, ob sich die Klasse noch korrekt compilieren lässt, bevor sie fortfahren.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Einfuehrung_002/readme.md

@@ -0,0 +1,26 @@
+# JavaDoc schreiben
+## Lernziel
+
+
+
+Eine vorhandene Klasse mit korrekten JavaDoc-Kommentaren versehen.
+
+## Aufgabe
+
+Im Paket [pr2.intro.javadoc](../sources/src/main/java/pr2/intro/javadoc/) finden Sie eine Klasse namens `Waehrung`, die eine Währung repräsentiert. Leider hat ein böser Geist bei dieser Klasse fast die gesamte JavaDoc gelöscht.
+
+Schreiben Sie eine sinnvolle JavaDoc für die Klasse `Waehrung`, die insbesondere die Funktion der Methoden und deren Parameter und Rückgabewerte erläutert. Vergessen Sie nicht, auch die Klasse selbst zu dokumentieren.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Einfuehrung_003/readme.md

@@ -0,0 +1,26 @@
+# Klasse mit JUnit testen
+## Lernziel
+
+
+
+Einen JUnit-Test für eine gegebene Klasse schreiben.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.intro.junit_faculty](../sources/src/main/java/pr2/intro/junit_faculty/).
+
+Schreiben Sie bitte einen JUnit-Test für folgende Klasse `Fakultaet`, der die Funktionalität der Methode `fact` testet. Denken Sie insbesondere daran, die Randfälle zu testen.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_001/readme.md

@@ -0,0 +1,32 @@
+# Einen generischen Typ schreiben
+## Lernziel
+
+
+
+Einen vorhandenen Typ so umgestalten, dass er als generischer Typ verwendet werden kann.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.einfach](../sources/src/main/java/pr2/generics/einfach/).
+
+Sie finden mit `Liste` eine sehr simple Implementierung einer einfach verketteten Liste vor. Zusätzlich gib es auch noch Tests, die die Liste testen.
+
+Führen Sie die Tests aus und überzeugen Sie sich, dass die Liste korrekt funktioniert.
+
+Schreiben Sie die Klasse `Liste` so um, dass sie zu einem generischen Typ wird. Dies bedeutet insbesondere, dass die Methoden `get` und `add` nicht mehr mit `Object` arbeiten, sondern typsicher werden. Sie dürfen in Ihrer Lösung __keine Casts__ verwenden, d.h. Sie müssen sich auch mit der Klasse `ListNode` beschäftigen und hier Änderungen vornehmen.
+
+Führen Sie die Tests erneut aus, um sicherzugehen, dass Sie bei Ihren Änderungen nichts kaputt gemacht haben.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_002/readme.md

@@ -0,0 +1,28 @@
+# Generische Klasse Pair schreiben
+## Lernziel
+
+
+
+Von einem generischen Typ erben.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.pair](../sources/src/main/java/pr2/generics/pair/).
+
+Schreiben Sie eine generische Klasse `Pair`, die zwei Objekte unterschiedlichen Typs verwalten kann. Die Instanzen von `Pair` sollen unveränderlich (**immutable**) sein.
+
+Testen Sie Ihre Implementierung mit der vorhandenen `Main`-Klasse.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_003/readme.md

@@ -0,0 +1,28 @@
+# Generische Klasse Pair erweitern: NumberPair
+## Lernziel
+
+
+
+Von einem generischen Typ erben.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.number_pair](../sources/src/main/java/pr2/generics/number_pair/).
+
+Schreiben Sie eine generische Klasse `NumberPair`, die von der Klasse `Pair` aus der vorhergehenden Aufgabe abgeleitet ist und erzwingt, dass beide verwaltete Objekte von `Number` oder einer Subklasse von `Number` (`Double`, `Integer`, `Long` etc.) sind.
+
+Testen Sie Ihre Implementierung mit der vorhandenen `Main`-Klasse.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_004/readme.md

@@ -0,0 +1,28 @@
+# Generische Klasse Pair erweitern: SamePair
+## Lernziel
+
+
+
+Von einem generischen Typ erben.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.same_pair](../sources/src/main/java/pr2/generics/same_pair/).
+
+Schreiben Sie eine generische Klasse `SamePair`, die von der Klasse `Pair` aus der vorhergehenden Aufgabe abgeleitet ist und erzwingt, dass beide verwaltete Objekte vom selben Typ sind.
+
+Testen Sie Ihre Implementierung mit der vorhandenen `Main`-Klasse.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_005/readme.md

@@ -0,0 +1,28 @@
+# PairList
+## Lernziel
+
+
+
+Sammlungen von Objekten eines generischen Typs erstellen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.pairlist](../sources/src/main/java/pr2/generics/pairlist/).
+
+Schreiben Sie eine generische Klasse `PairList`, die eine beliebige Anzahl von `Pair`-Objekten verwalten kann. Die Anzahl der maximal gespeicherten Objekte wird beim Erzeugen mitgegeben. Die Klasse erlaubt das Hinzufügen (`add`) und das Auslesen von Objekten anhand des Indexes (`get`).
+
+Testen Sie Ihre Implementierung mit der vorhandenen `Main`-Klasse.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_006/readme.md

@@ -0,0 +1,26 @@
+# Wildcard benutzen
+## Lernziel
+
+
+
+Wildcards einsetzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.printer](../sources/src/main/java/pr2/generics/printer/).
+
+Schreiben Sie eine Klasse `CollectionPrinter` mit einer statischen Methode `print`, der man eine beliebige (generische) Collection übergeben kann und die dann deren Inhalt ausdruckt. Eine _Collection_ ist eine Klasse, die beliebig viele Objekte verwalten kann und über die man mit der _for each_-Schleife iterieren kann.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_007/readme.md

@@ -0,0 +1,30 @@
+# Generische Queue
+## Lernziel
+
+
+
+Einen komplexeren generischen Typ entwickeln.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.queue](../sources/src/main/java/pr2/generics/queue/).
+
+Schreiben Sie eine generische Klasse `Queue`, die eine einfache Warteschlange (Queue) realisiert. Über die Methode `offer` können Objekte hinzugefügt werden, über `poll` wieder ausgelesen. Über Probleme des Over- und Underflows brauchen Sie sich hier keine Gedanken zu machen.
+
+Erweitern Sie die Klasse `Queue` um eine Methode `addAll`, der man eine andere `Queue` übergibt und die dann alle Elemente der übergebenen Queue in die aktuelle übernimmt.
+
+Erweitern Sie die Klasse `Queue` aus der vorhergehenden Aufgabe um eine Methode `copyInto`, der man eine andere `Queue` übergibt und die dann alle Elemente der aktuellen Queue in die übergebenen kopiert.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_008/readme.md

@@ -0,0 +1,35 @@
+# `super` und `extends` einsetzen
+## Lernziel
+
+
+
+Methoden unter Verwendung von `super` und `extends` gestalten, sodass sie flexibel auch mit Sub- bzw. Supertypen umgehen können.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.super_extends](../sources/src/main/java/pr2/generics/super_extends/).
+
+In dieser Aufgabe sollen Sie die Klasse `Liste` erweitern.
+
+Fügen Sie `Liste` zwei Methoden hinzu:
+
+  * `fillFrom`: befüllt die Liste mit den Daten aus einer anderen (übergebene) Liste.
+  * `copyInto`: kopiert die Daten der Liste in eine andere (übergebene) Liste.
+
+Verwenden Sie für Ihre Lösung `super` und `extends` zusammen mit Wildcards (`?`).
+
+Kommentieren Sie die Testmethode in den vorhandenen Tests ein und führen Sie diese danach aus. Versichern Sie sich, dass Ihre Implementierung korrekt funktioniert, bevor Sie die Lösung abgeben.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Generische_Typen_009/readme.md

@@ -0,0 +1,49 @@
+# Generische Typen zusammen mit Wildcards einsetzen
+## Lernziel
+
+
+
+Gebundene und ungebundene Wildcards einsetzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.generics.wildcards](../sources/src/main/java/pr2/generics/wildcards/).
+
+In dieser Aufgabe finden Sie bereits eine Implementierung einer generischen, auf Arrays basierenden Liste namens `SimpleList` vor. An dieser müssen Sie nichts verändern, sondern verwenden die Klasse wie sie ist.
+
+Schreiben Sie nun eine _nicht generische_ Klasse `ListHelper`, die zwei statische Methoden enthält:
+
+  * `printList`: Diese Methode bekommt eine beliebige `SimpleList` übergeben und druckt deren Inhalt einfach auf der Konsole aus. Deswegen hat die Methode auch den Rückgabetyp `void`.
+  * `sumList`: Diese Methode nimmt als Parameter `SimpleList`-Objekte, die irgendeine Form von Zahlen enthalten (`Number` oder Subklassen davon) und berechnet deren Summe. Das Ergebnis wird als `double`-Wert zurückgegeben.
+
+Verwenden Sie für die Methoden gebundene bzw. ungebundene Wildcards.
+
+Kommentieren Sie die entsprechenden Zeilen in der Klasse `Main` aus und sehen überprüfen Sie, ob Ihre Implementierungen auch wie gewünscht funktionieren. Die Ausgabe sollte sein:
+
+```console
+Dies
+ist
+ein
+Test
+.
+1
+2
+3
+4
+5
+15.0
+```
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Geschachtelte_Klassen_001/readme.md

@@ -0,0 +1,28 @@
+# MatrixSuche
+## Lernziel
+
+
+
+Statische innere Klassen einsetzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.lambda.matrixsuche](../sources/src/main/java/pr2/lambda/matrixsuche/).
+
+Schreiben Sie eine Klasse `MatrixSuche`, die eine statische Methode `findEntry` anbietet. Die Methode soll in einem zweidimensionalen `int`-Array nach einem gegebenen Eintrag suchen und die Position des gefundenen Eintrags in der Matrix zurückgeben. Um die Position zurückzugeben, verwenden Sie bitte eine statische innere Klasse namens `Position`, die die x- und y-Postion enthält.
+
+Überschreiben Sie die `toString`-Methode in `Position` und testen Sie, ob Ihre Implementierung richtig funktioniert.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Geschachtelte_Klassen_002/readme.md

@@ -0,0 +1,30 @@
+# Innere Klasse Beobachter
+## Lernziel
+
+
+
+Zugriff von inneren Klassen auf die umgebende Klasse.
+
+## Aufgabe
+
+Gehen Sie in das Paket: [pr2.lambda.observer](../sources/src/main/java/pr2/lambda/observer/).
+
+Dort finden Sie das Interface `Beobachter`.
+
+Schreiben Sie eine Klasse `Datenhalter`, die eine einziges, privates Attribut vom Typ `int` enthält. Setzen Sie das Attribut im Konstruktor, erzeugen Sie aber keinen Getter.
+
+Implementieren Sie das Interface `Beobachter` als nicht-statische, private innere Klasse in `Datenhalter` und erlauben Sie über den Beobachter Zugriff auf das Attribut, indem Sie ein entsprechendes Objekt vom Typ `Beobachter` zurückgeben. Testen Sie Ihre Implementierung mit einem JUnit-Test.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Geschachtelte_Klassen_003/readme.md

@@ -0,0 +1,30 @@
+# Callback mit anonymer Klasse realisieren
+## Lernziel
+
+
+
+Eine gegebene Funktion durch einen Callback parametrieren. Der Callback wird als anonyme innere Klasse realisiert.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.lambda.callback](../sources/src/main/java/pr2/lambda/callback/).
+
+In dieser Aufgabe wird ein sehr gängiges Muster benutzt, dass auch bei großen Suchmaschinen zum Einsatz kommt. Über eine Filter-Funktion werden aus einer Menge von Daten diejenigen ausgewählt, die gewünscht sind. Die Auswahlfunktion wird von außen vorgegeben, sodass beliebige Filteroperationen möglich sind, auch solche, die beim Schreiben des Rahmenwerkes noch nicht bekannt waren.
+
+Sehen Sie sich das Interface `Prediacte` und die Klasse `NumberSelector` an und versuchen Sie die Funktionsweise der beiden zu verstehen. Betrachten Sie nun die Klasse `Main`, die versucht zuerst die geraden und dann die ungeraden Zahlen auszuwählen und auszugeben. Der hierfür nötige Code ist zwar schon weitgehend vorhanden, aber in der `main`-Methode müssen Sie noch zwei passende Filterfunktionen als **anonyme innere Klassen** realisieren.
+
+Nachdem Sie die beiden Filter geschrieben haben, lassen Sie das Programm laufen und überprüfen Sie, ob wirklich die richtigen Zahlen ausgewählt werden.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_001/readme.md

@@ -0,0 +1,39 @@
+# `BufferedReader` zum zeilenweisen Lesen einsetzen
+## Lernziel
+
+
+
+Daten Zeilenweise mit einem `BufferedReader` verwenden und dabei das Decorator Pattern einsetzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.buffered_reader](../sources/src/main/java/pr2/io/buffered_reader/).
+
+Lesen Sie die Datei [kafka.txt](../sources/src/main/resources/pr2/io/buffered_reader/kafka.txt) zeilenweise ein und geben Sie die Zeilen mit einer fortlaufenden Zeilennummer wieder aus. Verwenden Sie hierzu einen `BufferedReader`.
+
+Eine beispielhafte Ausgabe sieht wie folgt aus:
+
+```console
+1: Verhaftung - Gespräch mit Frau Grubach - Dann Fräulein Bürstner
+2:
+3: Jemand mußte Josef K. verleumdet haben, denn ohne daß er etwas Böses
+4: getan hätte, wurde er eines Morgens verhaftet. Die Köchin der Frau
+5: Grubach, seiner Zimmervermieterin, die ihm jeden Tag gegen acht Uhr früh
+6: das Frühstück brachte, kam diesmal nicht. Das war noch niemals
+```
+
+Lassen Sie das Programm laufen und überprüfen Sie, ob die Ausgabe korrekt ist. Die Beispieldatei hat 232 Zeilen.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_002/readme.md

@@ -0,0 +1,38 @@
+# DataOutputStream
+## Lernziel
+
+
+
+Daten mit einem `DataOutputStreams` manuell serialisieren.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.datainputoutput_1](../sources/src/main/java/pr2/io/datainputoutput_1/).
+
+Schreiben Sie eine Klasse `DateWriter`, die ein Datum in der Form yyyy-MM-dd (z.B. 1997-08-29) von der Konsole annimmt und als `long`-Wert mithilfe eines `DataOutputStreams` in eine Datei schreibt.
+
+Schreiben Sie eine Klasse `DateReader`, die den `long`-Wert aus der Datei ausliest und wieder in das ursprüngliche Format bringt und auf der Konsole ausgibt.
+
+**Hinweis:** Zur Konvertierung eines Strings in ein Datum und umgekehrt, können Sie die Klasse `SimpleDateFormat` verwenden. Ein `Date`-Objekt lässt sich leicht über die Methode `getTime` in einen `long`-Wert umwandeln. Denken Sie an eine korrekte Behandlung von möglichen Fehlern.
+
+```console
+> java DateWriter 1997-08-29
+> java DateReader
+Das Datum war: 1997-08-29
+```
+
+**Zusatzfrage:** Welche besondere Bedeutung hat das hier als Beispiel verwendete Datum?
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_003/readme.md

@@ -0,0 +1,28 @@
+# DataOutputStream durch Serialisierung ersetzen
+## Lernziel
+
+
+
+Daten mit einem `ObjectOutputStreams` serialisieren.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.datainputoutput_2](../sources/src/main/java/pr2/io/datainputoutput_2/).
+
+Verändern Sie die beiden Klassen aus der vorhergehenden Aufgabe so, dass sie jetzt anstatt eines `DataOutputStreams` bzw. eines `DataInputStreams` Serialisierung verwenden.
+
+Vergleichen Sie bitte die Dateien, die bei diesem und der anderen Lösung entstanden sind. Was fällt ihnen auf?
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_004/readme.md

@@ -0,0 +1,53 @@
+# Daten mit `DataOutputStream` und `DataInputStream` verarbeiten
+## Lernziel
+
+
+
+Ein eigenes Format für die Daten einer Klasse definieren und diese Dann in einer Datei speichern und aus dieser wieder laden.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.data_output](../sources/src/main/java/pr2/io/data_output/).
+
+In dieser Aufgabe finden Sie bereits eine fertig implementierte Klasse `Board` vor, die ein Schachbrett repräsentiert. Allerdings wird dieses nicht für Schach benutzt, sondern für ein Spiel, bei dem man nur schwarze und weiße Steine auf das Brett stellen kann (z.B. Dame). Die Farbe der Steine wird durch die Enumeration `Color` dargestellt.
+
+Was bei dem Schachbrett allerdings noch fehlt, ist eine Möglichkeit den Spielstand zu speichern und später wieder einzulesen.
+
+Schauen Sie sich die Klassen `Board` und `Color` genau an und versuchen Sie diese zu verstehen. Sie können auch testweise ein Brett anlegen und mit Daten befüllen. (Wie dies geht, sehen Sie im JUnit-Test). Die `toString()`-Methode liefert eine anschauliche Darstellung des Spielfeldes.
+
+Implementieren Sie nun die Methoden `writeToFile` und `loadFromFile` unter Zuhilfenahme von `DateOutputStream` und `DataInputStream`. Hierzu müssen Sie noch das Datenformat für die Speicherung festlegen. Dieses ist wie folgt definiert:
+
+  1. Als erstes der String "Schachbrett" im UTF8-Format, um das Datenformat zu kennzeichnen.
+  2. Die Koordinaten der ersten Figur im Format x-Pos, y-Pos (beide als `byte`) und Farbe entsprechend `Color.ordinal()` (als `int`)
+  3. Wiederholung von Schritt 2. bis alle Figuren gespeichert sind.
+  4. Werte `0xff`, `0xff`, `-1`, um das Dateiende zu kennzeichnen
+
+Lassen Sie den JUnit-Test laufen, um zu sehen, ob die Daten korrekt verarbeitet werden.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_005/readme.md

@@ -0,0 +1,34 @@
+# Daten mit einem `InputStream` lesen
+## Lernziel
+
+
+
+Einen `InputStream` benutzen, um Daten aus einer Datei zu lesen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.datei_lesen](../sources/src/main/java/pr2/io/datei_lesen/).
+
+Lesen Sie die Daten aus der Datei [daten.dat](../sources/src/main/resources/pr2/io/datei_lesen/daten.dat) byteweise und geben Sie den Inhalt auf der Konsole aus. Für die Ausgabe verwenden Sie bitte die Hexadezimale Darstellung, also z.B. `0x0a` für den Wert 11.
+
+Lassen Sie das Programm laufen und betrachten Sie die Ausgabe. Wenn Sie alles korrekt implementiert haben, sollten Sie den Text
+
+    0xca 0xff 0xfe 0xba 0xbe 0x0 0xde 0xad 0xbe 0xef
+
+sehen.
+
+Denken Sie auch an eine Fehlerbehandlung für eventuelle Ausnahmen im Zusammenhang mit der Datei.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_006/readme.md

@@ -0,0 +1,36 @@
+# Daten mit einem `OutputStream` schreiben
+## Lernziel
+
+
+
+Einen `OutputStream` verwenden, um Daten zu schreiben.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.datei_schreiben](../sources/src/main/java/pr2/io/datei_schreiben/).
+
+In dieser Aufgabe sollen Sie eine Reihe von Bytes in eine Datei schreiben. Ein JUnit-Test wird überprüfen, ob Sie dies richtig getan haben.
+
+Öffnen Sie einen passenden `OutputStream`, um in die Datei `output/daten.dat` zu schreiben (verwenden Sie die Konstante `FILE` für den Dateinamen). Schreiben Sie nun die Byte-Folge
+
+```console
+0xca 0xff 0xfe 0xba 0xbe 0x0 0xde 0xad 0xbe 0xef
+```
+
+hinein und schließen Sie die Datei wieder.
+
+Führen Sie den JUnit-Test aus, der überprüft, ob alle Daten korrekt in die Datei geschrieben wurden.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_007/readme.md

@@ -0,0 +1,47 @@
+# Filesystem-Abstraktion mit `File`
+## Lernziel
+
+
+
+Die Klasse `Path` einsetzen, um plattformunabhängig Operationen auf dem Dateisystem durchzuführen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.file](../sources/src/main/java/pr2/io/file/).
+
+Benutzen Sie die Klasse `Path`, um die Festplatte Ihres Computers, ausgehend von dem als `root` bezeichneten Verzeichnis `../..` zu durchsuchen und die Größe der Verzeichnisse zu berechnen.
+
+Sie können die Größe eines Verzeichnisses nur indirekt bestimme, indem Sie die Größe aller Dateien in dem Verzeichnis addieren. Das Verzeichnis direkt kann man _nicht_ mit `size()`  nach seiner Größe fragen, wohl aber normale Dateien. Deswegen müssen Sie in Ihrem Programm immer sauber unterscheiden, ob ein Verzeichnis vorliegt (das sie rekursiv durchlaufen müssen) oder eine normale Datei (deren Größe Sie abfragen).
+
+Geben Sie die Verzeichnisse mit Ihrer Größe aus. Am Ende des Programms geben Sie noch die Gesamtgröße aller Unterverzeichnisse aus. Eine beispielhafte sähe wie folgt aus:
+
+```console
+Untersuche: /home/thomas/eclipse-workspace
+
+465 Byte - /home/thomas/eclipse-workspace/.recommenders/snipmatch/repositories
+1,4 kByte - /home/thomas/eclipse-workspace/.recommenders/snipmatch
+4,6 MByte - /home/thomas/eclipse-workspace/.recommenders
+57,5 MByte - /home/thomas/eclipse-workspace
+103 Byte - /home/thomas/lib/.settings
+5,8 MByte - /home/thomas/lib
+
+Gesamtgröße: 80,4 MByte
+```
+
+Lassen Sie Ihr Programm laufen und überprüfen Sie, ob die Ausgaben plausibel sind. Vergleichen Sie das Ergebnis mit den Angaben des Windows-Explorers, Mac-Finders oder Linux-Dateimanagers.
+
+Unter Linux und MacOS müssen Sie darauf achten, dass Sie symbolischen Links in Ihrem Programm nicht folgen, sonst zählen Sie möglicherweise zu viel.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_008/readme.md

@@ -0,0 +1,42 @@
+# Fileattribute lesen
+## Lernziel
+
+
+
+Methoden der Klassen `Path` und `Files` nutzen und verstehen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.filetest](../sources/src/main/java/pr2/io/filetest/).
+
+Schreiben Sie eine Klasse `FileInfo`, der man auf der Konsole einen Datei- oder Verzeichnisnamen übergeben kann. Sie soll dann einige grundlegende Informationen über die Datei ausgeben (siehe Beispiel).
+
+```console
+> java FileTest /Users/thomas/Documents/../Documents/
+/Users/thomas/Documents existiert
+/Users/thomas/Documents ist 408 Bytes groß
+/Users/thomas/Documents ist ein Verzeichnis
+/Users/thomas/Documents darf gelesen werden
+/Users/thomas/Documents darf geschrieben werden
+
+> java FileTest /Users/thomas/Documents/../Documents/Uebungsklausur.pages
+/Users/thomas/Documents/Uebungsklausur.pages existiert
+/Users/thomas/Documents/Uebungsklausur.pages ist 258920 Bytes groß
+/Users/thomas/Documents/Uebungsklausur.pages ist ein normale Datei
+/Users/thomas/Documents/Uebungsklausur.pages darf gelesen werden
+/Users/thomas/Documents/Uebungsklausur.pages darf geschrieben werden
+```
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_009/readme.md

@@ -0,0 +1,28 @@
+# `FilterReader`
+## Lernziel
+
+
+
+Einen eigenen Filter in Form eines `FilterReaders` programmieren und hiermit in den Datenstrom eingreifen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.filter](../sources/src/main/java/pr2/io/filter/).
+
+Vervollständigen Sie die Klasse `UCaseReader` so, dass Sie als Filter (`FilterReader`) verwendet werden kann. Die Aufgabe dieses Filters besteht darin, alle gelesenen Zeichen in Großbuchstaben umzuwandeln.
+
+Testen Sie, ob Ihre Implementierung korrekt ist, indem Sie die JUnit-Tests ausführen.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_010/readme.md

@@ -0,0 +1,30 @@
+# Konsolen Input/Output
+## Lernziel
+
+
+
+Daten von der Konsole lesen und über eine Ausgabeumlenkung in eine Datei umlenken. `PrintStream` und `InputStreamReader` einsetzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.konsole](../sources/src/main/java/pr2/io/konsole/).
+
+Lesen Sie zeilenweise mithilfe eines `BufferedReaders` von der Konsole Zeichen ein. Geben Sie diese wieder auf `System.out` aus und zeigen Sie die aktuelle Zeilennummer auf `System.err` an.
+
+Testen Sie das Programm.
+
+Lenken Sie nun die Ausgabe von `System.out` in die Datei `output/console.log` um (siehe Konstante `LOGFILE`). Lassen Sie das Programm erneut laufen und betrachten Sie danach die Datei mit den umgeleiteten Daten.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_011/readme.md

@@ -0,0 +1,31 @@
+# Zeilen einer Textdatei zählen
+## Lernziel
+
+
+
+Dateien zeilenweise lesen und verarbeiten.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.linecounter](../sources/src/main/java/pr2/io/linecounter/).
+
+Schreiben Sie eine Klasse `LineCounter`, die den Namen einer Textdatei von der Kommandozeile entgegennimmt und dann die Anzahl der Zeilen in der Datei ausgibt.
+
+```console
+> java LineCounter ../src/LineCounter.java
+Datei: ../src/LineCounter.java hat 30 Zeilen
+```
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_012/readme.md

@@ -0,0 +1,32 @@
+# `RandomAccessFile`
+## Lernziel
+
+
+
+`RandomAccessFile` sowohl zum Lesen, als auch zum Schreiben von Daten einsetzen. Verstehen, dass man sich wahlfrei durch die Datei bewegen kann.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.random_access](../sources/src/main/java/pr2/io/random_access/).
+
+Bei dieser Aufgabe werden Sie ein Verfahren anwenden, das bei sehr großen Datenmengen zum Einsatz kommt: das Sortieren der Daten direkt auf der Festplatte, ohne sie vollständig in den Hauptspeicher zu laden.
+
+Implementieren Sie einen [Bubblesort](https://de.wikipedia.org/wiki/Bubblesort) mithilfe von `RandomAccessFile` direkt auf einer Datei. Bubblesort ist ein ausgesprochen ineffizienter Algorithmus (O(n*n)), er ist aber sehr einfach zu implementieren. Da die zu sortierende Datei klein ist, können wir hier mit den Nachteilen von Bubblesort leben.
+
+Implementieren Sie die bereits vorhandene Methode `sortFile` der Klasse `FileSort`. Öffnen Sie zuerst die Datei mithilfe von `RandomAccessFile` im Modus `"rw"`. Wandern Sie nun - entsprechend dem Bubblesort-Algorithmus - über die Daten und sortieren Sie die Bytes der Datei. Halten Sie nie mehr als zwei `byte` und die Position als `long` im Speicher. Weitere Variablen können auch noch nötig sein, um den Algorithmus zu implementieren.
+
+Testen Sie Ihre Implementierung mit den JUnit-Tests. Die Testdatei für den Unit-Test ist [data.dat](../sources/src/main/resources/pr2/io/random_access/data.dat)
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_013/readme.md

@@ -0,0 +1,26 @@
+# `Reader` verwenden
+## Lernziel
+
+
+
+Textdaten mithilfe von `Reader` verarbeiten.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.reader_writer](../sources/src/main/java/pr2/io/reader_writer/).
+
+Lesen Sie die Datei [kafka.txt](../sources/src/main/resources/pr2/io/reader_writer/kafka.txt) mit einem passenden `Reader` ein und geben Sie sie auf der Konsole aus. Verwenden Sie nicht die `read()`-Methode, die einzelne Zeichen verarbeitet, sondern arbeiten Sie mit einem `char[]`-Buffer.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_014/readme.md

@@ -0,0 +1,36 @@
+# Rot13-Verschlüsselung
+## Lernziel
+
+
+
+Funktionsweise und Einsatz von Filtern.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.rot13](../sources/src/main/java/pr2/io/rot13/).
+
+Schreiben Sie eine Klasse `Rot13Reader`, die als Filter-Reader implementiert ist und jedes eingelesene Zeichen durch ein Zeichen ersetzt, dessen numerischer Wert um 13 höher ist (d.h. um 13 Schritte im Alphabet verschoben ist).
+
+Schreiben Sie eine Klasse `Rot13`, die einen Dateinamen von der Kommandozeile nimmt und diese Text-Datei mithilfe von `Rot13Reader` liest und auf der Konsole ausgibt.
+
+```console
+> cat /tmp/test
+DIES IST EIN TEXT, DER GLEICH ROT13 VERSCHLUESSELT WIRD.
+
+> java Rot13 /tmp/test
+QVR`-V`a-RV[-aRea9-QR_-TYRVPU-_\a>@-cR_`PUYbR``RYa-dV_Q;
+```
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_015/readme.md

@@ -0,0 +1,39 @@
+# Datei zerhacken
+## Lernziel
+
+
+
+Daten byteweise aus einem Stream lesen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.scrambler](../sources/src/main/java/pr2/io/scrambler/).
+
+Schreiben Sie eine Klasse `Scrambler`, die einen Dateinamen von der Kommandozeile entgegennimmt, die Datei einliest und dann wieder auf der Konsole ausgibt. Allerdings soll bei der Ausgabe nur jedes zweite Byte berücksichtigt werden.
+
+```console
+> java Scrambler ../src/Scrambler.java
+motjv.oFlIpttem
+motjv.oFlNtonEcpin
+motjv.oIEcpin
+pbi ls cabe
+  pbi ttcvi anSrn[ rs hosIEcpin{    i ag.egh! ){      Sse.r.rnl(
+  Bteen ae nee";      Sse.xt1;    }
+    ienuSra i;
+    r
+      i  e ienuSra(rs0)
+```
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Input_und_Output_016/readme.md

@@ -0,0 +1,34 @@
+# Serialisierung
+## Lernziel
+
+
+
+Serialisierung einsetzen können, um Objekte zu persistieren und wieder zu laden.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.io.serialisierung](../sources/src/main/java/pr2/io/serialisierung/).
+
+In dieser Aufgabe finden Sie bereits eine fertig implementierte Klasse `Board` vor, die ein Schachbrett repräsentiert. Allerdings wird dieses nicht für Schach benutzt, sondern für ein Spiel, bei dem man nur schwarze und weiße Steine auf das Brett stellen kann (z.B. Dame). Die Farbe der Steine wird durch die Enumeration `Color` dargestellt.
+
+Was bei dem Schachbrett allerdings noch fehlt, ist eine Möglichkeit den Spielstand zu speichern und später wieder einzulesen.
+
+Schauen Sie sich die Klassen `Board` und `Color` genau an und versuchen Sie diese zu verstehen. Sie können auch testweise ein Brett anlegen und mit Daten befüllen. (Wie dies geht, sehen Sie im JUnit-Test). Die `toString()`-Methode liefert eine anschauliche Darstellung des Spielfeldes.
+
+Implementieren Sie nun die Methoden `writeToFile` und `loadFromFile` unter Zuhilfenahme von Serialisierung. D.h. anders als in der Aufgabe zu `DataOutputStream`, sollen Sie hier kein eigenes Datenformat implementieren. Verwenden Sie stattdessen einen `ObjectOutputStream` bzw. `ObjectInputStream`.
+
+Lassen Sie den JUnit-Test laufen, um zu sehen, ob die Daten korrekt verarbeitet werden. Die Test-Datei für den Unit-Test ist [testdata.dat](../sources/src/main/resources/pr2/io/serialisierung/testdata.dat)
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Object_und_Wrapper_001/readme.md

@@ -0,0 +1,26 @@
+# Deep-Copy mit `clone()`
+## Lernziel
+
+
+
+Den Nutzen der `clone()`-Methode verstehen und diese richtig einsetzen. Eine eigene `clone()`-Methode schreiben und eine tiefe Kopie durchführen.
+
+## Aufgabe
+
+Im Paket [pr2.object.clone_alien](../sources/src/main/java/pr2/object/clone_alien/) fügen Sie der Klasse `Alien` eine `clone()`-Methode hinzu, die eine _tiefe Kopie_ der Objekte anlegt. Hierzu müssen Sie auch Raumanzug mit einer `clone()`-Methode ausstatten.
+
+Testen Sie, ob Ihre Implementierung korrekt funktioniert, indem Sie die vorhandenen Testfälle ausführen. Damit die Tests laufen können, müssen Sie die Kommentarzeichen entfernen.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Object_und_Wrapper_002/readme.md

@@ -0,0 +1,26 @@
+# Clone
+## Lernziel
+
+
+
+Den Nutzen der `clone()`-Methode verstehen und diese richtig einsetzen. Eine eigene `clone()`-Methode schreiben und eine tiefe Kopie durchführen.
+
+## Aufgabe
+
+Im Paket [pr2.object.clone_person](../sources/src/main/java/pr2/object/clone_person) finden Sie die Klasse `Person`.
+
+Erweitern Sie die Klasse bitte um eine `clone()`-Methode, die eine tiefe Kopie (**deep copy**) durchführt.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Object_und_Wrapper_003/readme.md

@@ -0,0 +1,32 @@
+# `equals()` und `hashCode()` implementieren und nutzen
+## Lernziel
+
+
+
+Die Methoden `equals()` und `hashCode()` der Klasse `Object` korrekt überschreiben und nutzen.
+
+## Aufgabe
+
+Im Projekt finden Sie ein Paket [pr2.object.equals_hashcode](../sources/src/main/java/pr2/object/equals_hashcode/) mit zwei Klassen `Wesen` und `Ork` und einen Testfall `WesenTest`.
+
+Wenn Sie den Test ausführen wird er nicht erfolgreich sein, da die Methoden `equals` und `hashCode` in der Klasse Ork fehlen.
+
+Schauen Sie sich die `equals`- und `hashCode`-Methoden in `Wesen` an und versuchen Sie die Methoden zu verstehen.
+
+Schreiben Sie im nächsten Schritt korrekte `equals`- und `hashCode`-Methoden für `Ork`. __Achtung:__ Sie sollten für Ihre Lösung die Klasse `Wesen` nicht verändern.
+
+Führen Sie den Test erneut aus, um sicherzustellen, dass die Methoden richtig funktionieren.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Object_und_Wrapper_004/readme.md

@@ -0,0 +1,26 @@
+# equals und hashCode
+## Lernziel
+
+
+
+Die Methoden `equals()` und `hashCode()` der Klasse `Object` korrekt überschreiben und nutzen.
+
+## Aufgabe
+
+Im Paket [pr2.object.equals_person](../sources/src/main/java/pr2/object/equals_person) finden Sie die Klasse `Person`.
+
+Geben Sie bitte den Java-Quelltext einer `equals`- und `hashCode`-Methode für diese Klasse an, die die in der Klasse `java.lang.Object` zugesicherte Äquivalenzbeziehung einhalten.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Object_und_Wrapper_005/readme.md

@@ -0,0 +1,38 @@
+# `toString()`-Methode implementieren
+## Lernziel
+
+
+
+Klassen mit einer `toString()`-Methode versehen und diese gegenseitig nutzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.object.tostring](../sources/src/main/java/pr2/object/tostring/).
+
+Lassen Sie die Klasse `Ausgabe` laufen und sehen Sie sich die Ausgabe an. Versuchen Sie zu verstehen, wie es zu dieser Ausgabe kommt und was sie bedeutet.
+
+Schreiben Sie im nächsten Schritt für die Klassen `Alien` und `Raumanzug` passende `toString()`-Methoden, sodass beim Aufruf der Klasse `Ausgabe` eine sinnvolle Ausgabe entsteht. Geben Sie
+
+  * den Namen des Aliens,
+  * die Marke des Raumanzuges und
+  * den vorhandenen Sauerstoffvorrat
+
+aus.
+
+Eine beispielhafte Ausgabe könnte wie folgt aussehen:
+
+`Ich bin ein Alien und heiße 'E.T.'. Ich trage einen Raumanzug von Spaceman 2000 (Füllstand 19%).`
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Object_und_Wrapper_006/readme.md

@@ -0,0 +1,28 @@
+# Optimierung bei Integer
+## Lernziel
+
+
+
+Wrapper-Klassen und deren Optimierungen verstehen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.object.wrapper_boxsearch](../sources/src/main/java/pr2/object/wrapper_boxsearch/).
+
+Bei den Wrapper-Typen (z.B. `Integer`) wird eine interne Optimierung durchgeführt, die dazu führt, dass bei Werten unterhalb einer bestimmten Schranke, beim Autoboxing immer wieder dasselbe Objekt verwendet wird, anstatt ein neues Wrapper-Objekt zu erzeugten.
+
+Schreiben Sie bitte ein Programm in der Klasse `BoxSearcher`, das für `Integer` diese Schranke sucht, indem es die Werte von `0` bis `200` auf diese Eigenschaft hin untersucht und für jeden Integer-Wert ausgibt, ob der Mechanismus bei ihm greift oder nicht.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

Object_und_Wrapper_007/readme.md

@@ -0,0 +1,39 @@
+# Methoden der Wrapper-Klassen
+## Lernziel
+
+
+
+Wrapper-Klassen nutzen, um Zahlen umzuwandeln.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.object.wrapper_umwandler](../sources/src/main/java/pr2/object/wrapper_umwandler/).
+
+Vervollständigen Sie die Klasse `Umwandler` so, dass die Methode `toString` eine Zahl nimmt und in vier verschiedenen Formaten ausgibt. Schauen Sie sich die Klasse `Integer` an und überlegen Sie, welche der vorhandenen statischen Methoden für das Problem passend sein könnten.
+
+Eine beispielhafte könnte wie folgt aussehen:
+
+```console
+Dezimal: 17871
+Hex    : 45cf
+Oktal  : 42717
+Binär  : 100010111001111
+```
+
+Im nächsten Schritt stellen Sie bitte die Methode `fromString` fertig. Auch hierzu sollten Sie sich die Klasse `Integer` genauer anschauen.
+
+Führen Sie das Programm aus und schauen Sie, ob das Ergebnis sinnvoll ist.
+
+
+<!--
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.
+-->

readme.md

@@ -18,9 +18,9 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
 | 4.  | Auffrischung          | [printf mit Formatstring](Auffrischung_004/readme.md)                                             |
 | 5.  | Auffrischung          | [Maximum in einem Array suchen](Auffrischung_005/readme.md)                                       |
 | 6.  | Auffrischung          | [Taschenrechner](Auffrischung_006/readme.md)                                                      |
-| 7.  | Einführung            | [Java-Coding-Standard anwenden](Einführung_001/readme.md)                                         |
-| 8.  | Einführung            | [JavaDoc schreiben](Einführung_002/readme.md)                                                     |
-| 9.  | Einführung            | [Klasse mit JUnit testen](Einführung_003/readme.md)                                               |
+| 7.  | Einführung            | [Java-Coding-Standard anwenden](Einfuehrung_001/readme.md)                                        |
+| 8.  | Einführung            | [JavaDoc schreiben](Einfuehrung_002/readme.md)                                                    |
+| 9.  | Einführung            | [Klasse mit JUnit testen](Einfuehrung_003/readme.md)                                              |
 | 10. | Strukturierung        | [Information-Hiding einer Klasse verbessern](Strukturierung_001/readme.md)                        |
 | 11. | Strukturierung        | [Vorhandene Bibliotheken als JAR einbinden](Strukturierung_002/readme.md)                         |
 | 12. | Vererbung             | [Final anwenden](Vererbung_001/readme.md)                                                         |
@@ -35,19 +35,19 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
 | 21. | Vererbung             | [Methoden überschreiben](Vererbung_010/readme.md)                                                 |
 | 22. | Vererbung             | [Varag-Methode schreiben](Vererbung_011/readme.md)                                                |
 | 23. | Vererbung             | [Vererbung von Figuren](Vererbung_012/readme.md)                                                  |
-| 24. | Abstrakte Klassen     | [Abstrakte Klassen](Abstrakte Klassen_001/readme.md)                                              |
-| 25. | Abstrakte Klassen     | [Abstrakte Klasse](Abstrakte Klassen_002/readme.md)                                               |
+| 24. | Abstrakte Klassen     | [Abstrakte Klassen](Abstrakte_Klassen_001/readme.md)                                              |
+| 25. | Abstrakte Klassen     | [Abstrakte Klasse](Abstrakte_Klassen_002/readme.md)                                               |
 | 26. | Interfaces            | [Comparable implementieren](Interfaces_001/readme.md)                                             |
 | 27. | Interfaces            | [Interface Stack entwerfen](Interfaces_002/readme.md)                                             |
 | 28. | Interfaces            | [Interface: Uebersetzer](Interfaces_003/readme.md)                                                |
 | 29. | Interfaces            | [Interfaces anwenden und entwerfen](Interfaces_004/readme.md)                                     |
-| 30. | Object und Wrapper    | [Deep-Copy mit `clone()`](Object und Wrapper_001/readme.md)                                       |
-| 31. | Object und Wrapper    | [Clone](Object und Wrapper_002/readme.md)                                                         |
-| 32. | Object und Wrapper    | [`equals()` und `hashCode()` implementieren und nutzen](Object und Wrapper_003/readme.md)         |
-| 33. | Object und Wrapper    | [equals und hashCode](Object und Wrapper_004/readme.md)                                           |
-| 34. | Object und Wrapper    | [`toString()`-Methode implementieren](Object und Wrapper_005/readme.md)                           |
-| 35. | Object und Wrapper    | [Optimierung bei Integer](Object und Wrapper_006/readme.md)                                       |
-| 36. | Object und Wrapper    | [Methoden der Wrapper-Klassen](Object und Wrapper_007/readme.md)                                  |
+| 30. | Object und Wrapper    | [Deep-Copy mit `clone()`](Object_und_Wrapper_001/readme.md)                                       |
+| 31. | Object und Wrapper    | [Clone](Object_und_Wrapper_002/readme.md)                                                         |
+| 32. | Object und Wrapper    | [`equals()` und `hashCode()` implementieren und nutzen](Object_und_Wrapper_003/readme.md)         |
+| 33. | Object und Wrapper    | [equals und hashCode](Object_und_Wrapper_004/readme.md)                                           |
+| 34. | Object und Wrapper    | [`toString()`-Methode implementieren](Object_und_Wrapper_005/readme.md)                           |
+| 35. | Object und Wrapper    | [Optimierung bei Integer](Object_und_Wrapper_006/readme.md)                                       |
+| 36. | Object und Wrapper    | [Methoden der Wrapper-Klassen](Object_und_Wrapper_007/readme.md)                                  |
 | 37. | Enumerationen         | [Eigene Enumeration schreiben und verwenden](Enumerationen_001/readme.md)                         |
 | 38. | Enumerationen         | [Enumeration schreiben](Enumerationen_002/readme.md)                                              |
 | 39. | Enumerationen         | [Singleton-Eigenschaft von Enumerationen](Enumerationen_003/readme.md)                            |
@@ -57,37 +57,37 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
 | 43. | Ausnahmen             | [Eigene Exception schreiben](Ausnahmen_003/readme.md)                                             |
 | 44. | Ausnahmen             | [Handle-or-Declare-Regel anwenden](Ausnahmen_004/readme.md)                                       |
 | 45. | Ausnahmen             | [Ausnahmen mit `try` und `catch` behandeln.](Ausnahmen_005/readme.md)                             |
-| 46. | Input und Output      | [`BufferedReader` zum zeilenweisen Lesen einsetzen](Input und Output_001/readme.md)               |
-| 47. | Input und Output      | [DataOutputStream](Input und Output_002/readme.md)                                                |
-| 48. | Input und Output      | [DataOutputStream durch Serialisierung ersetzen](Input und Output_003/readme.md)                  |
-| 49. | Input und Output      | [Daten mit `DataOutputStream` und `DataInputStream` verarbeiten](Input und Output_004/readme.md)  |
-| 50. | Input und Output      | [Daten mit einem `InputStream` lesen](Input und Output_005/readme.md)                             |
-| 51. | Input und Output      | [Daten mit einem `OutputStream` schreiben](Input und Output_006/readme.md)                        |
-| 52. | Input und Output      | [Filesystem-Abstraktion mit `File`](Input und Output_007/readme.md)                               |
-| 53. | Input und Output      | [Fileattribute lesen](Input und Output_008/readme.md)                                             |
-| 54. | Input und Output      | [`FilterReader`](Input und Output_009/readme.md)                                                  |
-| 55. | Input und Output      | [Konsolen Input/Output](Input und Output_010/readme.md)                                           |
-| 56. | Input und Output      | [Zeilen einer Textdatei zählen](Input und Output_011/readme.md)                                   |
-| 57. | Input und Output      | [`RandomAccessFile`](Input und Output_012/readme.md)                                              |
-| 58. | Input und Output      | [`Reader` verwenden](Input und Output_013/readme.md)                                              |
-| 59. | Input und Output      | [Rot13-Verschlüsselung](Input und Output_014/readme.md)                                           |
-| 60. | Input und Output      | [Datei zerhacken](Input und Output_015/readme.md)                                                 |
-| 61. | Input und Output      | [Serialisierung](Input und Output_016/readme.md)                                                  |
-| 62. | Generische Typen      | [Einen generischen Typ schreiben](Generische Typen_001/readme.md)                                 |
-| 63. | Generische Typen      | [Generische Klasse Pair schreiben](Generische Typen_002/readme.md)                                |
-| 64. | Generische Typen      | [Generische Klasse Pair erweitern: NumberPair](Generische Typen_003/readme.md)                    |
-| 65. | Generische Typen      | [Generische Klasse Pair erweitern: SamePair](Generische Typen_004/readme.md)                      |
-| 66. | Generische Typen      | [PairList](Generische Typen_005/readme.md)                                                        |
-| 67. | Generische Typen      | [Wildcard benutzen](Generische Typen_006/readme.md)                                               |
-| 68. | Generische Typen      | [Generische Queue](Generische Typen_007/readme.md)                                                |
-| 69. | Generische Typen      | [`super` und `extends` einsetzen](Generische Typen_008/readme.md)                                 |
-| 70. | Generische Typen      | [Generische Typen zusammen mit Wildcards einsetzen](Generische Typen_009/readme.md)               |
-| 71. | Geschachtelte Klassen | [Eigene compare-Methode schreiben](Geschachtelte Klassen_001/readme.md)                           |
-| 72. | Geschachtelte Klassen | [Innere Klasse Beobachter](Geschachtelte Klassen_002/readme.md)                                   |
-| 73. | Geschachtelte Klassen | [Callback mit anonymer Klasse realisieren](Geschachtelte Klassen_003/readme.md)                   |
+| 46. | Input und Output      | [`BufferedReader` zum zeilenweisen Lesen einsetzen](Input_und_Output_001/readme.md)               |
+| 47. | Input und Output      | [DataOutputStream](Input_und_Output_002/readme.md)                                                |
+| 48. | Input und Output      | [DataOutputStream durch Serialisierung ersetzen](Input_und_Output_003/readme.md)                  |
+| 49. | Input und Output      | [Daten mit `DataOutputStream` und `DataInputStream` verarbeiten](Input_und_Output_004/readme.md)  |
+| 50. | Input und Output      | [Daten mit einem `InputStream` lesen](Input_und_Output_005/readme.md)                             |
+| 51. | Input und Output      | [Daten mit einem `OutputStream` schreiben](Input_und_Output_006/readme.md)                        |
+| 52. | Input und Output      | [Filesystem-Abstraktion mit `File`](Input_und_Output_007/readme.md)                               |
+| 53. | Input und Output      | [Fileattribute lesen](Input_und_Output_008/readme.md)                                             |
+| 54. | Input und Output      | [`FilterReader`](Input_und_Output_009/readme.md)                                                  |
+| 55. | Input und Output      | [Konsolen Input/Output](Input_und_Output_010/readme.md)                                           |
+| 56. | Input und Output      | [Zeilen einer Textdatei zählen](Input_und_Output_011/readme.md)                                   |
+| 57. | Input und Output      | [`RandomAccessFile`](Input_und_Output_012/readme.md)                                              |
+| 58. | Input und Output      | [`Reader` verwenden](Input_und_Output_013/readme.md)                                              |
+| 59. | Input und Output      | [Rot13-Verschlüsselung](Input_und_Output_014/readme.md)                                           |
+| 60. | Input und Output      | [Datei zerhacken](Input_und_Output_015/readme.md)                                                 |
+| 61. | Input und Output      | [Serialisierung](Input_und_Output_016/readme.md)                                                  |
+| 62. | Generische Typen      | [Einen generischen Typ schreiben](Generische_Typen_001/readme.md)                                 |
+| 63. | Generische Typen      | [Generische Klasse Pair schreiben](Generische_Typen_002/readme.md)                                |
+| 64. | Generische Typen      | [Generische Klasse Pair erweitern: NumberPair](Generische_Typen_003/readme.md)                    |
+| 65. | Generische Typen      | [Generische Klasse Pair erweitern: SamePair](Generische_Typen_004/readme.md)                      |
+| 66. | Generische Typen      | [PairList](Generische_Typen_005/readme.md)                                                        |
+| 67. | Generische Typen      | [Wildcard benutzen](Generische_Typen_006/readme.md)                                               |
+| 68. | Generische Typen      | [Generische Queue](Generische_Typen_007/readme.md)                                                |
+| 69. | Generische Typen      | [`super` und `extends` einsetzen](Generische_Typen_008/readme.md)                                 |
+| 70. | Generische Typen      | [Generische Typen zusammen mit Wildcards einsetzen](Generische_Typen_009/readme.md)               |
+| 71. | Geschachtelte Klassen | [Eigene compare-Methode schreiben](Geschachtelte_Klassen_001/readme.md)                           |
+| 72. | Geschachtelte Klassen | [Innere Klasse Beobachter](Geschachtelte_Klassen_002/readme.md)                                   |
+| 73. | Geschachtelte Klassen | [Callback mit anonymer Klasse realisieren](Geschachtelte_Klassen_003/readme.md)                   |
 | 74. | Lambdas               | [Comparator als Lambda](Lambdas_001/readme.md)                                                    |
 | 75. | Lambdas               | [Callback mit Lambda realisieren](Lambdas_002/readme.md)                                          |
-| 76. | Geschachtelte Klassen | [MatrixSuche](Geschachtelte Klassen_001/readme.md)                                                |
+| 76. | Geschachtelte Klassen | [MatrixSuche](Geschachtelte_Klassen_001/readme.md)                                                |
 | 77. | Lambdas               | [StringTransmogrifier](Lambdas_001/readme.md)                                                     |
 | 78. | Lambdas               | [StringTransmogrifier erweitern](Lambdas_002/readme.md)                                           |
 | 79. | Collections           | [Iterator schreiben](Collections_001/readme.md)                                                   |