Update of exercises

Collections_001/readme.md

@@ -1,6 +1,6 @@
 # Iterator schreiben
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Für eine gegebene Klasse einen Iterator schreiben.

Collections_001/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Iterator schreiben
+
+Musterlösung:
+
+[pr2.collections.iterator](../../solutions/src/main/java/pr2/collections/iterator/)

Collections_002/readme.md

@@ -1,6 +1,6 @@
 # Iterator programmieren
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Iteratoren verstehen und programmieren.

Collections_002/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Iterator programmieren
+
+Musterlösung:
+
+[pr2.collections.list_iterator](../../solutions/src/main/java/pr2/collections/list_iterator/)

Collections_003/readme.md

@@ -1,6 +1,6 @@
 # `List<T>` und dessen Implementierungen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Das Interface `List<T>` und eine passende Implementierung einsetzen.

Collections_003/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: `List<T>` und dessen Implementierungen
+
+Musterlösung:
+
+[pr2.collections.list](../../solutions/src/main/java/pr2/collections/list/)

Collections_004/readme.md

@@ -1,6 +1,6 @@
 # `Map<T>` verwenden
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Das Interface `Map<T>` und seine Implementierungen verwenden, um Daten effizient zu verarbeiten.

Collections_004/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: `Map<T>` verwenden
+
+Musterlösung:
+
+[pr2.collections.map](../../solutions/src/main/java/pr2/collections/map/)

Collections_005/readme.md

@@ -1,6 +1,6 @@
 # ReverserGeneric
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 `Comparable` verstehen und nutzen.

Collections_005/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: ReverserGeneric
+
+Musterlösung:
+
+[pr2.collections.reverser_generic](../../solutions/src/main/java/pr2/collections/reverser_generic/)

Collections_006/readme.md

@@ -1,6 +1,6 @@
 # Strings umgekehrt sortieren: Reverser
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 `Comparable` verstehen und nutzen.

Collections_006/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Strings umgekehrt sortieren: Reverser
+
+Musterlösung:
+
+[pr2.collections.reverser](../../solutions/src/main/java/pr2/collections/reverser/)

Collections_007/readme.md

@@ -1,6 +1,6 @@
 # `Set<T>` und dessen Implementierungen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Das Interface `Set<T>` und eine passende Implementierung einsetzen.

Collections_007/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: `Set<T>` und dessen Implementierungen
+
+Musterlösung:
+
+[pr2.collections.set](../../solutions/src/main/java/pr2/collections/set/)

Collections_008/readme.md

@@ -1,6 +1,6 @@
 # CommandLineSorter
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Sortieren von Collections.

Collections_008/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: CommandLineSorter
+
+Musterlösung:
+
+[pr2.collections.sorter_1](../../solutions/src/main/java/pr2/collections/sorter_1/)

Collections_009/readme.md

@@ -1,6 +1,6 @@
 # CommandLineSorter -- Version 2
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Sortieren von Collections.

Collections_009/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: CommandLineSorter -- Version 2
+
+Musterlösung:
+
+[pr2.collections.sorter_2](../../solutions/src/main/java/pr2/collections/sorter_2/)

Collections_010/readme.md

@@ -1,6 +1,6 @@
 # `Comparator<T>` verwenden und Objekte sortieren
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Verschiedene Sortierreihenfolgen durch die Implementierung von `Comparator<T>` realisieren.

Collections_010/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: `Comparator<T>` verwenden und Objekte sortieren
+
+Musterlösung:
+
+[pr2.collections.sortieren](../../solutions/src/main/java/pr2/collections/sortieren/)

Collections_011/readme.md

@@ -1,6 +1,6 @@
 # Wörterbuchprogramm
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Interface `Map` und seine Implementierungen einsetzen.

Collections_011/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Wörterbuchprogramm
+
+Musterlösung:
+
+[pr2.collections.woerterbuch](../../solutions/src/main/java/pr2/collections/woerterbuch/)

Streams_001/readme.md

@@ -1,6 +1,6 @@
 # Kleinbuchstaben in einem String zählen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Streams verwenden.

Streams_001/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Kleinbuchstaben in einem String zählen
+
+Musterlösung:
+
+[pr2.streams.chars_1](../.. /solutions/src/main/java/pr2/streams/chars_1/)

Streams_002/readme.md

@@ -1,6 +1,6 @@
 # Buchstaben in einer Liste von Strings zählen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Streams verwenden.

Streams_002/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Buchstaben in einer Liste von Strings zählen
+
+Musterlösung:
+
+[pr2.streams.chars_2](../.. /solutions/src/main/java/pr2/streams/chars_2/)

Streams_003/readme.md

@@ -1,6 +1,6 @@
 # Kleinbuchstaben in einem String zählen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Streams verwenden.

Streams_003/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Kleinbuchstaben in einem String zählen
+
+Musterlösung:
+
+[pr2.streams.chars_3](../.. /solutions/src/main/java/pr2/streams/chars_3/)

Streams_004/readme.md

@@ -1,6 +1,6 @@
 # Liste filtern
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Daten in Streams filtern.

Streams_004/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Liste filtern
+
+Musterlösung:
+
+[pr2.streams.filter](../.. /solutions/src/main/java/pr2/streams/filter/)

Streams_005/readme.md

@@ -1,6 +1,6 @@
 # Streams mit interner Iteration
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Einen Stream mit einer internen Iteration verwenden. Die Iteration sowohl mit einem Lambda, als auch mit einer Methodenreferenz durchführen.

Streams_005/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Streams mit interner Iteration
+
+Musterlösung:
+
+[pr2.streams.interne_iteration](../../solutions/src/main/java/pr2/streams/interne_iteration/)

Streams_006/readme.md

@@ -1,6 +1,6 @@
 # Map und Filter auf Streams
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Einen Stream durch Map- und Filter-Operationen analysieren und gewünschte Daten extrahieren.

Streams_006/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Map und Filter auf Streams
+
+Musterlösung:
+
+[pr2.streams.map_filter](../../solutions/src/main/java/pr2/streams/map_filter/)

Streams_007/readme.md

@@ -1,6 +1,6 @@
 # Map und Reduce auf Streams
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Die Daten in einem Stream durch Map- und Reduce verdichten.

Streams_007/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Map und Reduce auf Streams
+
+Musterlösung:
+
+[pr2.streams.reduce_critics](../../solutions/src/main/java/pr2/streams/reduce_critics/)

Streams_008/readme.md

@@ -1,6 +1,6 @@
 # Reduce
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Daten in Streams mit `reduce` aggregieren.

Streams_008/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Reduce
+
+Musterlösung:
+
+[pr2.streams.reduce](../../solutions/src/main/java/pr2/streams/reduce/)

Streams_009/readme.md

@@ -1,6 +1,6 @@
 # Summe über reduce bestimmen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Daten in Streams mit `reduce` aggregieren.

Streams_009/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Summe über reduce bestimmen
+
+Musterlösung:
+
+[pr2.streams.summieren](../../solutions/src/main/java/pr2/streams/summieren/)

Streams_010/readme.md

@@ -1,6 +1,6 @@
 # Wörter zählen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Daten in Streams mit `reduce` aggregieren.

Streams_010/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Wörter zählen
+
+Musterlösung:
+
+[pr2.streams.word_count](../../solutions/src/main/java/pr2/streams/word_count/)

Threads_001/readme.md

@@ -1,6 +1,6 @@
 # Fakultät parallel berechnen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Berechnungen parallelisieren.

Threads_001/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Fakultät parallel berechnen
+
+Musterlösung:
+
+[pr2.threads.fakultaet](../../solutions/src/main/java/pr2/threads/fakultaet/)

Threads_002/readme.md

@@ -1,6 +1,6 @@
 # Thread per interrupt beenden
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Threads kontrolliert beenden.

Threads_002/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Thread per interrupt beenden
+
+Musterlösung:
+
+[pr2.threads.interrupt](../../solutions/src/main/java/pr2/threads/interrupt/)

Threads_003/readme.md

@@ -1,6 +1,6 @@
 # wait und notify benutzen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Thread-Koordination über Condition-Variablen.

Threads_003/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: wait und notify benutzen
+
+Musterlösung:
+
+[pr2.threads.notifier](../../solutions/src/main/java/pr2/threads/notifier/)

Threads_004/readme.md

@@ -1,6 +1,6 @@
 # Parallele Ausgaben erzeugen
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Erste Schritte mit Threads.

Threads_004/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Parallele Ausgaben erzeugen
+
+Musterlösung:
+
+[pr2.threads.paralleldrucker](../../solutions/src/main/java/pr2/threads/paralleldrucker/)

Threads_005/readme.md

@@ -1,6 +1,6 @@
 # Race-Condition finden und beheben
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 In einem gegebenen Programm Race-Conditions finden und durch den Einsatz von kritischen Abschnitten beheben.

Threads_005/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Race-Condition finden und beheben
+
+Musterlösung:
+
+[pr2.threads.race_condition](../../solutions/src/main/java/pr2/threads/race_condition/)

Threads_006/readme.md

@@ -1,6 +1,6 @@
 # Stack und Heap unterscheiden
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Unterschied zwischen Stack und Heap bei parallelen Programmen verstehen.

Threads_006/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Stack und Heap unterscheiden
+
+Musterlösung:
+
+[pr2.threads.stack_heap](../../solutions/src/main/java/pr2/threads/stack_heap/)

Threads_007/readme.md

@@ -1,6 +1,6 @@
 # synchronized verwenden
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Schlüsselwort `synchronized` verwenden.

Threads_007/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: synchronized verwenden
+
+Musterlösung:
+
+[pr2.threads.synchronize](../../solutions/src/main/java/pr2/threads/synchronize/)

Threads_008/readme.md

@@ -1,6 +1,6 @@
 # Timer und TimerTask verwenden
 ## Lernziel
-
+ [Musterlösung](solution/)
 
 
 Klassen aus `java.util.concurrent` verwenden.

Threads_008/solution/readme.md

@@ -0,0 +1,5 @@
+# Lösung: Timer und TimerTask verwenden
+
+Musterlösung:
+
+[pr2.threads.timer](../../solutions/src/main/java/pr2/threads/timer/)

readme.md

@@ -90,34 +90,34 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
 | 76. | Geschachtelte Klassen | [MatrixSuche](Geschachtelte_Klassen_001/readme.md)                                                |  [✅](Geschachtelte_Klassen_001/solution/) |
 | 77. | Lambdas               | [StringTransmogrifier](Lambdas_001/readme.md)                                                     |  [✅](Lambdas_001/solution/) |
 | 78. | Lambdas               | [StringTransmogrifier erweitern](Lambdas_002/readme.md)                                           |  [✅](Lambdas_002/solution/) |
-| 79. | Collections           | [Iterator schreiben](Collections_001/readme.md)                                                   |   |
+| 79. | Collections           | [Iterator schreiben](Collections_001/readme.md)                                                   |  [✅](Collections_001/solution/) |
-| 80. | Collections           | [Iterator programmieren](Collections_002/readme.md)                                               |   |
+| 80. | Collections           | [Iterator programmieren](Collections_002/readme.md)                                               |  [✅](Collections_002/solution/) |
-| 81. | Collections           | [`List<T>` und dessen Implementierungen](Collections_003/readme.md)                               |   |
+| 81. | Collections           | [`List<T>` und dessen Implementierungen](Collections_003/readme.md)                               |  [✅](Collections_003/solution/) |
-| 82. | Collections           | [`Map<T>` verwenden](Collections_004/readme.md)                                                   |   |
+| 82. | Collections           | [`Map<T>` verwenden](Collections_004/readme.md)                                                   |  [✅](Collections_004/solution/) |
-| 83. | Collections           | [ReverserGeneric](Collections_005/readme.md)                                                      |   |
+| 83. | Collections           | [ReverserGeneric](Collections_005/readme.md)                                                      |  [✅](Collections_005/solution/) |
-| 84. | Collections           | [Strings umgekehrt sortieren: Reverser](Collections_006/readme.md)                                |   |
+| 84. | Collections           | [Strings umgekehrt sortieren: Reverser](Collections_006/readme.md)                                |  [✅](Collections_006/solution/) |
-| 85. | Collections           | [`Set<T>` und dessen Implementierungen](Collections_007/readme.md)                                |   |
+| 85. | Collections           | [`Set<T>` und dessen Implementierungen](Collections_007/readme.md)                                |  [✅](Collections_007/solution/) |
-| 86. | Collections           | [CommandLineSorter](Collections_008/readme.md)                                                    |   |
+| 86. | Collections           | [CommandLineSorter](Collections_008/readme.md)                                                    |  [✅](Collections_008/solution/) |
-| 87. | Collections           | [CommandLineSorter -- Version 2](Collections_009/readme.md)                                       |   |
+| 87. | Collections           | [CommandLineSorter -- Version 2](Collections_009/readme.md)                                       |  [✅](Collections_009/solution/) |
-| 88. | Collections           | [`Comparator<T>` verwenden und Objekte sortieren](Collections_010/readme.md)                      |   |
+| 88. | Collections           | [`Comparator<T>` verwenden und Objekte sortieren](Collections_010/readme.md)                      |  [✅](Collections_010/solution/) |
-| 89. | Collections           | [Wörterbuchprogramm](Collections_011/readme.md)                                                   |   |
+| 89. | Collections           | [Wörterbuchprogramm](Collections_011/readme.md)                                                   |  [✅](Collections_011/solution/) |
-| 90. | Streams               | [Kleinbuchstaben in einem String zählen](Streams_001/readme.md)                                   |   |
+| 90. | Streams               | [Kleinbuchstaben in einem String zählen](Streams_001/readme.md)                                   |  [✅](Streams_001/solution/) |
-| 91. | Streams               | [Buchstaben in einer Liste von Strings zählen](Streams_002/readme.md)                             |   |
+| 91. | Streams               | [Buchstaben in einer Liste von Strings zählen](Streams_002/readme.md)                             |  [✅](Streams_002/solution/) |
-| 92. | Streams               | [Kleinbuchstaben in einem String zählen](Streams_003/readme.md)                                   |   |
+| 92. | Streams               | [Kleinbuchstaben in einem String zählen](Streams_003/readme.md)                                   |  [✅](Streams_003/solution/) |
-| 93. | Streams               | [Liste filtern](Streams_004/readme.md)                                                            |   |
+| 93. | Streams               | [Liste filtern](Streams_004/readme.md)                                                            |  [✅](Streams_004/solution/) |
-| 94. | Streams               | [Streams mit interner Iteration](Streams_005/readme.md)                                           |   |
+| 94. | Streams               | [Streams mit interner Iteration](Streams_005/readme.md)                                           |  [✅](Streams_005/solution/) |
-| 95. | Streams               | [Map und Filter auf Streams](Streams_006/readme.md)                                               |   |
+| 95. | Streams               | [Map und Filter auf Streams](Streams_006/readme.md)                                               |  [✅](Streams_006/solution/) |
-| 96. | Streams               | [Map und Reduce auf Streams](Streams_007/readme.md)                                               |   |
+| 96. | Streams               | [Map und Reduce auf Streams](Streams_007/readme.md)                                               |  [✅](Streams_007/solution/) |
-| 97. | Streams               | [Reduce](Streams_008/readme.md)                                                                   |   |
+| 97. | Streams               | [Reduce](Streams_008/readme.md)                                                                   |  [✅](Streams_008/solution/) |
-| 98. | Streams               | [Summe über reduce bestimmen](Streams_009/readme.md)                                              |   |
+| 98. | Streams               | [Summe über reduce bestimmen](Streams_009/readme.md)                                              |  [✅](Streams_009/solution/) |
-| 99. | Streams               | [Wörter zählen](Streams_010/readme.md)                                                            |   |
+| 99. | Streams               | [Wörter zählen](Streams_010/readme.md)                                                            |  [✅](Streams_010/solution/) |
-| 100. | Threads               | [Fakultät parallel berechnen](Threads_001/readme.md)                                              |   |
+| 100. | Threads               | [Fakultät parallel berechnen](Threads_001/readme.md)                                              |  [✅](Threads_001/solution/) |
-| 101. | Threads               | [Thread per interrupt beenden](Threads_002/readme.md)                                             |   |
+| 101. | Threads               | [Thread per interrupt beenden](Threads_002/readme.md)                                             |  [✅](Threads_002/solution/) |
-| 102. | Threads               | [wait und notify benutzen](Threads_003/readme.md)                                                 |   |
+| 102. | Threads               | [wait und notify benutzen](Threads_003/readme.md)                                                 |  [✅](Threads_003/solution/) |
-| 103. | Threads               | [Parallele Ausgaben erzeugen](Threads_004/readme.md)                                              |   |
+| 103. | Threads               | [Parallele Ausgaben erzeugen](Threads_004/readme.md)                                              |  [✅](Threads_004/solution/) |
-| 104. | Threads               | [Race-Condition finden und beheben](Threads_005/readme.md)                                        |   |
+| 104. | Threads               | [Race-Condition finden und beheben](Threads_005/readme.md)                                        |  [✅](Threads_005/solution/) |
-| 105. | Threads               | [Stack und Heap unterscheiden](Threads_006/readme.md)                                             |   |
+| 105. | Threads               | [Stack und Heap unterscheiden](Threads_006/readme.md)                                             |  [✅](Threads_006/solution/) |
-| 106. | Threads               | [synchronized verwenden](Threads_007/readme.md)                                                   |   |
+| 106. | Threads               | [synchronized verwenden](Threads_007/readme.md)                                                   |  [✅](Threads_007/solution/) |
-| 107. | Threads               | [Timer und TimerTask verwenden](Threads_008/readme.md)                                            |   |
+| 107. | Threads               | [Timer und TimerTask verwenden](Threads_008/readme.md)                                            |  [✅](Threads_008/solution/) |
 | 108. | Reflection            | [Klasse per Reflection analysieren](Reflection_001/readme.md)                                     |   |
 | 109. | Reflection            | [Objekte per Reflection erzeugen](Reflection_002/readme.md)                                       |   |

solutions/src/main/java/pr2/collections/iterator/SimpleStack.java

@@ -0,0 +1,79 @@
+package pr2.collections.iterator;
+
+import java.util.Iterator;
+
+/**
+ * Eine einfache, naive Stack Implementierung.
+ *
+ * @param <T> Typ, der gespeichert werden soll.
+ */
+public class SimpleStack<T> implements Iterable<T> {
+
+    // Variablen sind nicht private wegen Zugriff durch den Iterator
+    T[] stack;
+
+    int pos;
+
+    /**
+     * Legt einen neuen Stack mit der gegebenen Größe an.
+     *
+     * @param size Größe des Stacks.
+     */
+    @SuppressWarnings("unchecked")
+    public SimpleStack(int size) {
+        stack = (T[]) new Object[size];
+        pos = 0;
+    }
+
+    /**
+     * Fügt dem Stack ein neues Element hinzu.
+     *
+     * @param o Element, das hinzugefügt werden soll.
+     */
+    public void push(T o) {
+        stack[pos++] = o;
+    }
+
+    /**
+     * Holt das oberste Element und entfernt es.
+     *
+     * @return das oberste Element
+     */
+    public T pop() {
+        return stack[--pos];
+    }
+
+    /**
+     * Gibt das oberste Element zurück, ohne es zu entfernen.
+     *
+     * @return das oberste Element
+     */
+    public T peek() {
+        return stack[pos - 1];
+    }
+
+
+    /**
+     * Erzeugt einen Iterator.
+     *
+     * @return Iterator
+     * @see java.lang.Iterable#iterator()
+     */
+    @Override
+    public Iterator<T> iterator() {
+        return new Iterator<T>() {
+
+            int iteratorPos = pos - 1;
+
+            @Override
+            public boolean hasNext() {
+                return iteratorPos >= 0;
+            }
+
+            @Override
+            public T next() {
+                return stack[iteratorPos--];
+            }
+        };
+    }
+}

solutions/src/main/java/pr2/collections/iterator/test/SimpleStackTest.java

@@ -0,0 +1,86 @@
+package pr2.collections.iterator.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.collections.iterator.SimpleStack;
+
+import java.util.Iterator;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Test für den Stack.
+ */
+public class SimpleStackTest {
+
+    /**
+     * Testet den Stack an sich.
+     */
+    @Test
+    void testStack() {
+        SimpleStack<String> s = new SimpleStack<>(10);
+        s.push("A");
+        s.push("B");
+        s.push("C");
+        s.push("D");
+        assertEquals("D", s.peek());
+        assertEquals("D", s.pop());
+        assertEquals("C", s.pop());
+        assertEquals("B", s.pop());
+        s.push("A2");
+        s.push("A3");
+        assertEquals("A3", s.peek());
+        assertEquals("A3", s.pop());
+        assertEquals("A2", s.pop());
+        assertEquals("A", s.pop());
+    }
+
+
+    /**
+     * Testet den Iterator.
+     */
+    @Test
+    void testIterator() {
+        SimpleStack<String> s = new SimpleStack<>(10);
+        s.push("A");
+        s.push("B");
+        s.push("C");
+        s.push("D");
+
+        String[] result = new String[5];
+        int count = 0;
+
+        for (String string : s) {
+            result[count++] = string;
+        }
+
+        assertEquals("D", s.peek());
+
+        assertEquals("D", result[0]);
+        assertEquals("C", result[1]);
+        assertEquals("B", result[2]);
+        assertEquals("A", result[3]);
+
+        s.push("E");
+
+        Iterator<String> it = s.iterator();
+
+        count = 0;
+        while (it.hasNext()) {
+            result[count++] = it.next();
+        }
+
+        assertEquals("E", result[0]);
+        assertEquals("D", result[1]);
+        assertEquals("C", result[2]);
+        assertEquals("B", result[3]);
+        assertEquals("A", result[4]);
+
+        assertFalse(it.hasNext());
+
+        it = s.iterator();
+
+        assertTrue(it.hasNext());
+    }
+}

solutions/src/main/java/pr2/collections/list/WordCollector.java

@@ -0,0 +1,123 @@
+package pr2.collections.list;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Klassen, um die in einem Text vorkommenden Wörter zu sammeln.
+ */
+public class WordCollector {
+
+
+    /**
+     * Listet alle Worte in der Datei alphabetisch auf. Duplikate werden
+     * entfernt. Die Wörter werden in Kleinbuchstaben umgewandelt.
+     *
+     * @param filename Dateiname
+     * @return die Liste der vorhandenen Worte
+     * @throws IOException Fehler beim Dateizugriff.
+     */
+    public static List<String> listWords(String filename) throws IOException {
+        List<String> allWords = readFileAndSplitIntoWords(filename);
+        List<String> result = removeDuplicates(allWords);
+
+        return result;
+    }
+
+    /**
+     * Listet alle Worte in der Datei auf.
+     *
+     * @param filename Dateiname
+     * @return die Liste der vorhandenen Worte
+     * @throws IOException Fehler beim Dateizugriff.
+     */
+    private static List<String> readFileAndSplitIntoWords(String filename)
+            throws IOException {
+
+        // Datei zum Lesen öffnen
+        BufferedReader reader = new BufferedReader(new FileReader(filename));
+
+        String line; // aktuelle Zeile
+
+        List<String> wordList = new LinkedList<>();
+
+        // Über die Zeilen der Datei iterieren
+        while ((line = reader.readLine()) != null) {
+
+            // Sonderzeichen entfernen und die Zeilen in Worte splitten
+            line = line.toLowerCase();
+            line = line.replaceAll("[\",.:'\\-!?]", "");
+
+            String[] words = line.toLowerCase().split("[,. ]");
+
+            // Worte in den Puffer übertragen
+            wordList.addAll(Arrays.asList(words));
+        }
+
+        reader.close();
+
+        return wordList;
+    }
+
+    /**
+     * Sortiert das übergebene Array alphabetisch und entfernt Duplikate.
+     *
+     * @param input Eingabe Array
+     * @return sortiertes und bereinigtes Array
+     */
+    @SuppressWarnings("PMD.AvoidReassigningLoopVariables")
+    private static List<String> removeDuplicates(List<String> input) {
+
+        // Eingabe-Liste kopieren
+        List<String> strings = new ArrayList<>(input);
+
+        // Liste sortieren
+        Collections.sort(strings);
+
+        // Über die Einträge laufen
+        for (int i = 0; i < strings.size(); i++) {
+
+            String word = strings.get(i);
+
+            // Über die Einträge laufen
+            for (int k = i + 1; k < strings.size(); k++) {
+
+                String otherWord = strings.get(k);
+
+                if (otherWord.compareTo(word) > 0) {
+                    // Sind schon hinter der möglichen Position
+                    break;
+                }
+                else if (otherWord.equals(word)) {
+                    // Duplikat, entfernen
+                    strings.remove(k);
+                    k--;
+                }
+            }
+        }
+
+        return strings;
+    }
+
+    /**
+     * Hauptmethode.
+     *
+     * @param args Kommandozeilen-Argumente.
+     */
+    public static void main(String[] args) {
+
+        try {
+            List<String> words = listWords(
+                    "kafka.txt");
+            System.out.println(words);
+        } catch (IOException e) {
+            System.err.println("Probleme beim Dateizugriff: " + e);
+        }
+    }
+}

solutions/src/main/java/pr2/collections/list_iterator/Liste.java

@@ -0,0 +1,57 @@
+package pr2.collections.list_iterator;
+
+import java.util.Iterator;
+public class Liste<T> implements Iterable<T> {
+
+    static class Item<T> {
+        T element;
+        Item<T> next;
+
+        public Item(T element) {
+            this.element = element;
+        }
+    }
+
+    Item<T> first;
+    Item<T> last;
+
+    class ListenIterator implements Iterator<T> {
+        Item<T> position = first;
+
+        @Override
+        public boolean hasNext() {
+            return (position != null);
+        }
+
+        @Override
+        public T next() {
+            T element = position.element;
+            position = position.next;
+            return element;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public void add(T element) {
+        Item<T> item = new Item<T>(element);
+
+        first = (first != null) ? first : item;
+
+        if (last == null) {
+            last = item;
+        } else {
+            last.next = item;
+            last = item;
+        }
+
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return new ListenIterator();
+    }
+}

solutions/src/main/java/pr2/collections/map/WordCount.java

@@ -0,0 +1,83 @@
+package pr2.collections.map;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Zählen von Worthäufigkeiten.
+ */
+public class WordCount {
+
+    /**
+     * Listet alle Worte in der Datei und deren Häufigkeit auf.
+     * Die zurückgegebene Liste ist bereits nach der Häufigkeit
+     * sortiert.
+     *
+     * @param filename Dateiname
+     * @return die Liste der vorhandenen Wörter
+     * @throws IOException Fehler beim Dateizugriff.
+     */
+    private static List<WordFrequency> countWords(String filename)
+            throws IOException {
+
+        // Map mit dem Wort als Schlüssel und der Häufigkeit als Key
+        Map<String, WordFrequency> frequencyMap = new HashMap<>();
+
+        // Datei zum Lesen öffnen
+        BufferedReader reader = new BufferedReader(new FileReader(filename));
+
+        String line; // aktuelle Zeile
+
+        // Über die Zeilen der Datei iterieren
+        while ((line = reader.readLine()) != null) {
+
+            // Sonderzeichen entfernen und die Zeilen in Worte splitten
+            line = line.toLowerCase();
+            line = line.replaceAll("[\",.:;)'\\-!?]", "");
+
+            String[] words = line.toLowerCase().split("[,. ]");
+
+            for (String word : words) {
+                WordFrequency entry = frequencyMap.get(word);
+                if (entry == null) {
+                    entry = new WordFrequency(word, 0);
+                    frequencyMap.put(word, entry);
+                }
+
+                entry.incrementFrequency();
+            }
+        }
+
+        reader.close();
+
+        List<WordFrequency> liste = new ArrayList<>(frequencyMap.values());
+        Collections.sort(liste);
+
+        return liste;
+    }
+
+    /**
+     * Hauptmethode.
+     *
+     * @param args Kommandozeilen-Argumente.
+     */
+    public static void main(String[] args) {
+
+        try {
+            List<WordFrequency> words = countWords(
+                    "kafka.txt");
+
+            for (WordFrequency word : words) {
+                System.out.println(word);
+            }
+        } catch (IOException e) {
+            System.err.println("Probleme beim Dateizugriff: " + e);
+        }
+    }
+}

solutions/src/main/java/pr2/collections/map/WordFrequency.java

@@ -0,0 +1,56 @@
+package pr2.collections.map;
+
+/**
+ * Klasse für die Verwaltung der Worthäufigkeiten.
+ */
+public class WordFrequency implements Comparable<WordFrequency> {
+
+    /**
+     * Das Wort.
+     */
+    String word;
+
+    /**
+     * Seine Häufigkeit.
+     */
+    int frequency;
+
+    /**
+     * Legt ein neues Objekt an.
+     *
+     * @param word      das gespeicherte Wort
+     * @param frequency die Häfigkeit
+     */
+    WordFrequency(String word, int frequency) {
+        this.word = word;
+        this.frequency = frequency;
+    }
+
+
+    /**
+     * Vergleich mit anderem Objekt.
+     *
+     * @param o das andere Objekt
+     * @return Ergebnis des Vergleiches
+     * @see java.lang.Comparable#compareTo(java.lang.Object)
+     */
+    @Override
+    public int compareTo(WordFrequency o) {
+        return o.frequency - frequency;
+    }
+
+    /**
+     * Erhöht die Häufigkeit des Wortes.
+     */
+    public void incrementFrequency() {
+        frequency++;
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return String.format("%s: %d", word, frequency);
+    }
+}

solutions/src/main/java/pr2/collections/reverser/Reverser.java

@@ -0,0 +1,18 @@
+package pr2.collections.reverser;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class Reverser {
+    public void reverse(List<String> liste) {
+
+        Collections.sort(liste, new Comparator<String>() {
+
+            @Override
+            public int compare(String o1, String o2) {
+                return o1.compareTo(o2) * -1;
+            }
+        });
+    }
+}

solutions/src/main/java/pr2/collections/reverser/test/ReverserTest.java

@@ -0,0 +1,23 @@
+package pr2.collections.reverser.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.collections.reverser.Reverser;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ReverserTest {
+
+    @Test
+    void testReverser() {
+        List<String> testListe = Arrays.asList("Meier", "Zabelmann", "Schulze",
+                "Xavier", "Albert");
+        new Reverser().reverse(testListe);
+        assertEquals(Arrays.asList(
+                "Zabelmann", "Xavier", "Schulze", "Meier", "Albert"),
+                        testListe);
+    }
+
+}

solutions/src/main/java/pr2/collections/reverser_generic/Reverser.java

@@ -0,0 +1,19 @@
+package pr2.collections.reverser_generic;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class Reverser<T extends Comparable<T>> {
+
+    public void reverse(List<T> liste) {
+
+        Collections.sort(liste, new Comparator<T>() {
+
+            @Override
+            public int compare(T o1, T o2) {
+                return o1.compareTo(o2) * -1;
+            }
+        });
+    }
+}

solutions/src/main/java/pr2/collections/reverser_generic/test/ReverserTest.java

@@ -0,0 +1,23 @@
+package pr2.collections.reverser_generic.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.collections.reverser_generic.Reverser;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ReverserTest {
+
+    @Test
+    void testReverser() {
+        List<String> testListe = Arrays.asList("Meier", "Zabelmann", "Schulze",
+                "Xavier", "Albert");
+        new Reverser<String>().reverse(testListe);
+        assertEquals(Arrays.asList(
+                "Zabelmann", "Xavier", "Schulze", "Meier", "Albert"),
+                        testListe);
+    }
+
+}

solutions/src/main/java/pr2/collections/set/WordCollector.java

@@ -0,0 +1,81 @@
+package pr2.collections.set;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Klassen, um die in einem Text vorkommenen Wörter zu sammeln.
+ */
+public class WordCollector {
+
+
+    /**
+     * Listet alle Worte in der Datei alphabetisch auf. Duplikate werden
+     * entfernt. Die Wörter werden in Kleinbuchstaben umgewandelt.
+     *
+     * @param filename Dateiname
+     * @return die Liste der vorhandenen Worte
+     * @throws IOException Fehler beim Dateizugriff.
+     */
+    public static List<String> listWords(String filename) throws IOException {
+        Set<String> allWords = readFileAndSplitIntoWords(filename);
+        List<String> wordsSorted = new ArrayList<>(allWords);
+        Collections.sort(wordsSorted);
+        return wordsSorted;
+    }
+
+    /**
+     * Listet alle Worte in der Datei auf.
+     *
+     * @param filename Dateiname
+     * @return die Liste der vorhandenen Worte
+     * @throws IOException Fehler beim Dateizugriff.
+     */
+    private static Set<String> readFileAndSplitIntoWords(String filename)
+            throws IOException {
+
+        // Datei zum Lesen öffnen
+        BufferedReader reader = new BufferedReader(new FileReader(filename));
+
+        String line; // aktuelle Zeile
+        Set<String> wordBuffer = new HashSet<>(); // Puffer für die Worte
+
+        // Über die Zeilen der Datei iterieren
+        while ((line = reader.readLine()) != null) {
+
+            // Sonderzeichen entfernen und die Zeilen in Worte splitten
+            line = line.replaceAll("[\",.:'\\-!?]", "");
+
+            String[] words = line.toLowerCase().split("[,. ]");
+
+            // Worte in den Puffer übertragen
+            wordBuffer.addAll(Arrays.asList(words));
+        }
+
+        reader.close();
+
+        return wordBuffer;
+    }
+
+    /**
+     * Hauptmethode.
+     *
+     * @param args Kommandozeilen-Argumente.
+     */
+    public static void main(String[] args) {
+
+        try {
+            List<String> words = listWords("kafka.txt");
+            System.out.println(words);
+        } catch (IOException e) {
+            System.err.println("Probleme beim Dateizugriff: " + e);
+        }
+    }
+}

solutions/src/main/java/pr2/collections/sorter_1/CommandLineSorter.java

@@ -0,0 +1,17 @@
+package pr2.collections.sorter_1;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class CommandLineSorter {
+
+    public static void main(String[] args) {
+        List<String> argList = Arrays.asList(args);
+        Collections.sort(argList);
+
+        for (String element : argList) {
+            System.out.println(element);
+        }
+    }
+}

solutions/src/main/java/pr2/collections/sorter_2/CommandLineSorter.java

@@ -0,0 +1,16 @@
+package pr2.collections.sorter_2;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class CommandLineSorter {
+
+    public static void main(String[] args) {
+        Set<String> argList = new TreeSet<String>(Arrays.asList(args));
+
+        for (String element : argList) {
+            System.out.println(element);
+        }
+    }
+}

solutions/src/main/java/pr2/collections/sortieren/Sorter.java

@@ -0,0 +1,83 @@
+package pr2.collections.sortieren;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * Klasse zum Sortieren von Strings.
+ */
+public class Sorter {
+
+    /**
+     * Liefert einen Comparator für Strings.
+     *
+     * @param order Sortierreihenfolge.
+     * @return Comparator, entsprechend der gewünschten Sortierreihenfolge.
+     */
+    private static Comparator<String> stringComparator(final SortOrder order) {
+        /* Comparator. */
+        class MyComparator implements Comparator<String> {
+
+            /**
+             * Vergleicht die Strings.
+             *
+             * @param o1 Erster String
+             * @param o2 Zweiter String
+             * @return Ergebnis des Vergleichs.
+             */
+            @Override
+            public int compare(String o1, String o2) {
+                switch (order) {
+                    case ASCENDING:
+                        return o1.compareTo(o2);
+                    case DESCENDING:
+                        return -o1.compareTo(o2);
+                    case ASCENDING_CASE_INSENSITIVE:
+                        return o1.toUpperCase().compareTo(o2.toUpperCase());
+                    case DESCENDING_CASE_INSENSITIVE:
+                        return -o1.toUpperCase().compareTo(o2.toUpperCase());
+                    default:
+                        throw new IllegalArgumentException();
+                }
+            }
+        }
+
+        return new MyComparator();
+    }
+
+    /**
+     * Sortiert das übergebene Array entsprechend der gewünschten Reihenfolge.
+     *
+     * @param array das zu sortierende Array.
+     * @param order die Sortierreihenfolge.
+     */
+    public static void sort(String[] array, SortOrder order) {
+        Arrays.sort(array, stringComparator(order));
+    }
+
+    /**
+     * Sortierreihenfolge für die Strings.
+     */
+    public enum SortOrder {
+
+        /**
+         * Aufsteigend.
+         */
+        ASCENDING,
+
+        /**
+         * Absteigend.
+         */
+        DESCENDING,
+
+        /**
+         * Aufsteigend, ohne Beachtung der Groß-/Kleinschreibung.
+         */
+        ASCENDING_CASE_INSENSITIVE,
+
+        /**
+         * Absteigend, ohne Beachtung der Groß-/Kleinschreibung.
+         */
+        DESCENDING_CASE_INSENSITIVE
+    }
+}

solutions/src/main/java/pr2/collections/sortieren/test/SorterTest.java

@@ -0,0 +1,75 @@
+package pr2.collections.sortieren.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.collections.sortieren.Sorter;
+import pr2.collections.sortieren.Sorter.SortOrder;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+
+/**
+ * Test für die Sortierung.
+ */
+public class SorterTest {
+
+    private static final String[] DATA =
+            {"aaron", "ALFONS", "bond", "BerND", "henry", "Hugo"};
+
+    /**
+     * Testet die Sortierung: aufsteigend.
+     */
+    @Test
+    void testAscendingSorting() {
+
+        String[] asc = DATA.clone();
+
+        Sorter.sort(asc, SortOrder.ASCENDING);
+
+        assertArrayEquals(
+                new String[] {"ALFONS", "BerND", "Hugo", "aaron", "bond",
+                        "henry"}, asc);
+    }
+
+    /**
+     * Testet die Sortierung: Absteigend.
+     */
+    @Test
+    void testDescendingSorting() {
+
+        String[] desc = DATA.clone();
+        Sorter.sort(desc, SortOrder.DESCENDING);
+
+        assertArrayEquals(
+                new String[] {"henry", "bond", "aaron", "Hugo", "BerND",
+                        "ALFONS"}, desc);
+    }
+
+    /**
+     * Testet die Sortierung: Aufsteigend, CI.
+     */
+    @Test
+    void testAscendingCISorting() {
+
+        String[] ascCI = DATA.clone();
+        Sorter.sort(ascCI, SortOrder.ASCENDING_CASE_INSENSITIVE);
+
+        assertArrayEquals(
+                new String[] {"aaron", "ALFONS", "BerND", "bond", "henry",
+                        "Hugo"}, ascCI);
+    }
+
+    /**
+     * Testet die Sortierung: Absteigend, CI.
+     */
+    @Test
+    void testDescendingCISorting() {
+
+        String[] descCI = DATA.clone();
+
+        Sorter.sort(descCI, SortOrder.DESCENDING_CASE_INSENSITIVE);
+
+        assertArrayEquals(
+                new String[] {"Hugo", "henry", "bond", "BerND", "ALFONS",
+                        "aaron"}, descCI);
+    }
+}

solutions/src/main/java/pr2/collections/woerterbuch/Woerterbuch.java

@@ -0,0 +1,37 @@
+package pr2.collections.woerterbuch;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Woerterbuch {
+
+    private static final Map<String, String> WOERTER;
+
+    static {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("gehen", "go");
+        map.put("schlafen", "sleep");
+        map.put("tanzen", "dance");
+        map.put("springen", "jump");
+
+        WOERTER = Collections.unmodifiableMap(map);
+    }
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.err.println("Bitte mindestens ein Wort angeben!");
+            System.exit(1);
+        }
+
+        for (String wort : args) {
+            String uebersetzung = WOERTER.get(wort);
+
+            if (uebersetzung == null) {
+                uebersetzung = "<unbekanntes Wort>";
+            }
+
+            System.out.printf("%s => %s%n", wort, uebersetzung);
+        }
+    }
+}

solutions/src/main/java/pr2/enums/eigene/WuerfelTyp.java

@@ -1,4 +1,3 @@
-
 package pr2.enums.eigene;
 
 /**

solutions/src/main/java/pr2/exceptions/handle_or_declare/Buchstabenzaehler.java

@@ -18,7 +18,6 @@ public class Buchstabenzaehler {
      */
     public static void main(String[] args) {
         Buchstabenzaehler bs = new Buchstabenzaehler();
-
         try {
             bs.run();
         }
@@ -40,9 +39,6 @@ public class Buchstabenzaehler {
 
         int[] statistik;
 
-
-
-
         try {
             statistik = parseFile("assets/" + dateiname);
             printStatistik(statistik);

solutions/src/main/java/pr2/generics/einfach/Liste.java

@@ -5,7 +5,6 @@ package pr2.generics.einfach;
  *
  * @param <T> Typ der gespeicherten Objekte
  */
-
 public class Liste<T> {
 
     /**

solutions/src/main/java/pr2/generics/einfach/ListeNode.java

@@ -1,6 +1,5 @@
 package pr2.generics.einfach;
 
-
 /**
  * Interne Repräsentation der Knoten in der Liste.
  *

solutions/src/main/java/pr2/interfaces/uebersetzer/Translator.java

@@ -1,4 +1,3 @@
-
 package pr2.interfaces.uebersetzer;
 
 public class Translator {

solutions/src/main/java/pr2/interfaces/uebersetzer/UebersetzerDeutschEnglisch.java

@@ -1,4 +1,3 @@
-
 package pr2.interfaces.uebersetzer;
 
 public class UebersetzerDeutschEnglisch implements Uebersetzer {

solutions/src/main/java/pr2/interfaces/uebersetzer/UebersetzerDeutschSpanisch.java

@@ -1,4 +1,3 @@
-
 package pr2.interfaces.uebersetzer;
 
 public class UebersetzerDeutschSpanisch implements Uebersetzer {

solutions/src/main/java/pr2/intro/coding_standard/CodingStandard.java

@@ -4,7 +4,6 @@ package pr2.intro.coding_standard;
  * Klasse dient als Beispiel für den Coding-Standard und die Namenskonventionen
  * bei Java-Programmen.
  */
-
 @SuppressWarnings("PMD.UnusedPrivateField")
 public class CodingStandard {
 

solutions/src/main/java/pr2/intro/javadoc/Waehrung.java

@@ -1,6 +1,5 @@
 package pr2.intro.javadoc;
 
-
 /**
  * Objekte dieser Klasse repräsentieren eine Währung. Eine Währung zeichnet
  * sich durch einen Namen (z.B. EURO), ein Kürzel (z.B. € oder EUR) und einen

solutions/src/main/java/pr2/lambda/observer/Datenhalter.java

@@ -1,4 +1,3 @@
-
 package pr2.lambda.observer;
 
 public class Datenhalter {

solutions/src/main/java/pr2/lambda/observer/DatenhalterAnonym.java

@@ -1,4 +1,3 @@
-
 package pr2.lambda.observer;
 
 public class DatenhalterAnonym {

solutions/src/main/java/pr2/lambda/observer/test/BeobachterTest.java

@@ -1,4 +1,3 @@
-
 package pr2.lambda.observer.test;
 
 import org.junit.jupiter.api.Test;

solutions/src/main/java/pr2/streams/chars_1/CountLetters.java

@@ -0,0 +1,13 @@
+package pr2.streams.chars_1;
+
+public class CountLetters {
+    public static long count(String s) {
+        long sum;
+
+        sum = s.chars()
+                .filter(Character::isLowerCase)
+                .count();
+
+        return sum;
+    }
+}

solutions/src/main/java/pr2/streams/chars_1/test/CountLettersTest.java

@@ -0,0 +1,16 @@
+package pr2.streams.chars_1.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.streams.chars_1.CountLetters;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class CountLettersTest {
+    @Test
+    void testCount() {
+        String s = "Dies ist ein String mit einer ganzen Reihe von "
+                + "Buchstaben.";
+
+        assertEquals(44, CountLetters.count(s));
+    }
+}

solutions/src/main/java/pr2/streams/chars_2/CountLetters.java

@@ -0,0 +1,16 @@
+package pr2.streams.chars_2;
+
+import java.util.List;
+
+public class CountLetters {
+    public static long count(List<String> liste) {
+
+        long chars;
+
+        chars = liste.stream()
+                .flatMapToInt(s -> s.chars())
+                .count();
+
+        return chars;
+    }
+}

solutions/src/main/java/pr2/streams/chars_2/test/CountLettersTest.java

@@ -0,0 +1,19 @@
+package pr2.streams.chars_2.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.streams.chars_2.CountLetters;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class CountLettersTest {
+    @Test
+    void testCount() {
+        List<String> liste = Arrays.asList("Hallo", "Welt", "wie", "geht",
+                "es");
+
+        assertEquals(18, CountLetters.count(liste));
+    }
+}

solutions/src/main/java/pr2/streams/chars_3/CountLetters.java

@@ -0,0 +1,17 @@
+package pr2.streams.chars_3;
+
+import java.util.List;
+
+public class CountLetters {
+    public static long count(List<String> liste) {
+
+        long chars;
+
+        chars = liste.stream()
+                .flatMapToInt(s -> s.chars())
+                .filter(Character::isLowerCase)
+                .count();
+
+        return chars;
+    }
+}

solutions/src/main/java/pr2/streams/chars_3/test/CountLettersTest.java

@@ -0,0 +1,19 @@
+package pr2.streams.chars_3.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.streams.chars_3.CountLetters;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class CountLettersTest {
+    @Test
+    void testCount() {
+        List<String> liste = Arrays.asList("Hallo", "Welt", "wie", "geht",
+                "es");
+
+        assertEquals(16, CountLetters.count(liste));
+    }
+}

solutions/src/main/java/pr2/streams/filter/FilterList.java

@@ -0,0 +1,17 @@
+package pr2.streams.filter;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FilterList {
+    public static List<String> filter(List<String> liste) {
+        List<String> result;
+
+        result = liste.stream()
+                .filter(s -> s.length() >= 5)
+                .map(String::toLowerCase)
+                .collect(Collectors.toList());
+
+        return result;
+    }
+}

solutions/src/main/java/pr2/streams/filter/test/FilterListTest.java

@@ -0,0 +1,25 @@
+package pr2.streams.filter.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.streams.filter.FilterList;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class FilterListTest {
+
+    @Test
+    void testFilter() {
+        List<String> liste = Arrays.asList(
+                "Hallo", "Welt", "Dampfschifffahrt", "Hundekuchen",
+                "Fiction", "Java", "Visual Basic", "Drucker");
+
+        List<String> result = Arrays.asList(
+                "hallo", "dampfschifffahrt", "hundekuchen",
+                "fiction", "visual basic", "drucker");
+
+        assertEquals(result, FilterList.filter(liste));
+    }
+}

solutions/src/main/java/pr2/streams/interne_iteration/ComputerGame.java

@@ -0,0 +1,87 @@
+package pr2.streams.interne_iteration;
+
+/**
+ * Computerspiel.
+ */
+public class ComputerGame {
+
+    /**
+     * Name.
+     */
+    private final String name;
+
+    /**
+     * Jahr.
+     */
+    private final int year;
+
+    /**
+     * Metacritic.
+     */
+    private final int metaScore;
+
+    /**
+     * Userscore.
+     */
+    private final int userScore;
+
+    /**
+     * Legt ein neues Spiel an.
+     *
+     * @param name      Name des Spiels.
+     * @param year      Jahr.
+     * @param metaScore Metacritic-Bewertung.
+     * @param userScore Nutzer-Bewertung.
+     */
+    public ComputerGame(String name, int year, int metaScore, int userScore) {
+        this.name = name;
+        this.year = year;
+        this.metaScore = metaScore;
+        this.userScore = userScore;
+    }
+
+    /**
+     * Name des Spiels.
+     *
+     * @return Der Name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Jahr, in dem das Spiel erschienen ist bzw. kritisiert wurde.
+     *
+     * @return Das Erscheinungsjahr.
+     */
+    public int getYear() {
+        return year;
+    }
+
+    /**
+     * Die Metacritic-Bewertung (0-100).
+     *
+     * @return Die Bewertung.
+     */
+    public int getMetaScore() {
+        return metaScore;
+    }
+
+    /**
+     * Die Benutzerbewertung (0-100).
+     *
+     * @return Die Benutzerbewertung.
+     */
+    public int getUserScore() {
+        return userScore;
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return String.format("%d;%s;%s;%d", metaScore, name, userScore / 10.0,
+                year);
+    }
+}

solutions/src/main/java/pr2/streams/interne_iteration/GameDatabase.java

@@ -0,0 +1,61 @@
+package pr2.streams.interne_iteration;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Datenbank für die Spiele.
+ */
+public class GameDatabase {
+
+    private final List<ComputerGame> games;
+
+    /**
+     * Datenbank mit Spieleinfomrationen.
+     */
+    @SuppressWarnings("deprecation")
+    public GameDatabase() {
+        games = new ArrayList<>();
+
+        try {
+            BufferedReader br =
+                    new BufferedReader(new FileReader(
+                            "games.txt"));
+
+            String line;
+
+            while ((line = br.readLine()) != null) {
+                String[] tokens = line.split(";");
+                int metacritic = Integer.parseInt(tokens[0]);
+                String name = tokens[1];
+                int userScore = (int) (Double.parseDouble(tokens[2]) * 10);
+                Date date =
+                        new SimpleDateFormat("MMM d, yyyy", Locale.US).parse(
+                                tokens[3]);
+
+                games.add(new ComputerGame(name, date.getYear() + 1900,
+                        metacritic, userScore));
+            }
+
+            br.close();
+        } catch (IOException | ParseException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    /**
+     * Gibt die Liste der Spiele zurück.
+     *
+     * @return Liste der Spiele
+     */
+    public List<ComputerGame> getGames() {
+        return new ArrayList<>(games);
+    }
+}

solutions/src/main/java/pr2/streams/interne_iteration/ListGames.java

@@ -0,0 +1,39 @@
+package pr2.streams.interne_iteration;
+
+import java.util.stream.Stream;
+
+/**
+ * Spiele auflisten.
+ */
+public class ListGames {
+
+    /**
+     * Hauptmethode.
+     *
+     * @param args Kommandozeilenargumente.
+     */
+    public static void main(String[] args) {
+        GameDatabase db = new GameDatabase();
+
+        System.out.println("Interne Iterartion");
+        System.out.println();
+        Stream<ComputerGame> stream = db.getGames().stream();
+        stream.forEach(g -> System.out.println(g));
+
+        System.out.println();
+        System.out.println();
+        System.out.println("Interne Iterartion mit Methodenreferenz");
+        stream = db.getGames().stream();
+        stream.forEach(System.out::println);
+
+        System.out.println();
+        System.out.println();
+        System.out.println("Spiele aus 2012");
+        stream = db.getGames().stream();
+        stream.forEach(g -> {
+            if (g.getYear() == 2012) {
+                System.out.println(g);
+            }
+        });
+    }
+}

solutions/src/main/java/pr2/streams/map_filter/ComputerGame.java

@@ -0,0 +1,88 @@
+package pr2.streams.map_filter;
+
+/**
+ * Computerspiel.
+ */
+public class ComputerGame {
+
+    /**
+     * Name.
+     */
+    private final String name;
+
+    /**
+     * Jahr.
+     */
+    private final int year;
+
+    /**
+     * Metacritic.
+     */
+    private final int metaScore;
+
+    /**
+     * Userscore.
+     */
+    private final int userScore;
+
+    /**
+     * Legt ein neues Spiel an.
+     *
+     * @param name      Name des Spiels.
+     * @param year      Jahr.
+     * @param metaScore Metacritic-Bewertung.
+     * @param userScore Nutzer-Bewertung.
+     */
+    public ComputerGame(String name, int year, int metaScore, int userScore) {
+
+        this.name = name;
+        this.year = year;
+        this.metaScore = metaScore;
+        this.userScore = userScore;
+    }
+
+    /**
+     * Name des Spiels.
+     *
+     * @return Der Name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Jahr, in dem das Spiel erschienen ist bzw. kritisiert wurde.
+     *
+     * @return Das Erscheinungsjahr.
+     */
+    public int getYear() {
+        return year;
+    }
+
+    /**
+     * Die Metacritic-Bewertung (0-100).
+     *
+     * @return Die Bewertung.
+     */
+    public int getMetaScore() {
+        return metaScore;
+    }
+
+    /**
+     * Die Benutzerbewertung (0-100).
+     *
+     * @return Die Benutzerbewertung.
+     */
+    public int getUserScore() {
+        return userScore;
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return String.format("%d;%s;%s;%d", metaScore, name, userScore / 10.0,
+                year);
+    }
+}

solutions/src/main/java/pr2/streams/map_filter/GameDatabase.java

@@ -0,0 +1,61 @@
+package pr2.streams.map_filter;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Datenbank für die Spiele.
+ */
+public class GameDatabase {
+
+    private final List<ComputerGame> games;
+
+    /**
+     * Datenbank mit Spieleinfomrationen.
+     */
+    @SuppressWarnings("deprecation")
+    public GameDatabase() {
+        games = new ArrayList<>();
+
+        try {
+            BufferedReader br =
+                    new BufferedReader(new FileReader(
+                            "games.txt"));
+
+            String line;
+
+            while ((line = br.readLine()) != null) {
+                String[] tokens = line.split(";");
+                int metacritic = Integer.parseInt(tokens[0]);
+                String name = tokens[1];
+                int userScore = (int) (Double.parseDouble(tokens[2]) * 10);
+                Date date =
+                        new SimpleDateFormat("MMM d, yyyy", Locale.US).parse(
+                                tokens[3]);
+
+                games.add(new ComputerGame(name, date.getYear() + 1900,
+                        metacritic, userScore));
+            }
+
+            br.close();
+        } catch (IOException | ParseException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    /**
+     * Gibt die Liste der Spiele zurück.
+     *
+     * @return Liste der Spiele
+     */
+    public List<ComputerGame> getGames() {
+        return new ArrayList<>(games);
+    }
+}