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/auffrischung/suchemax/GroessteZahl.java

@@ -3,7 +3,7 @@ package pr2.auffrischung.suchemax;
 public class GroessteZahl {
 
     public int sucheMax(int[] zahlen) {
-        int max = Integer.MIN_VALUE; 
+        int max = Integer.MIN_VALUE;
 
         for (int zahl : zahlen) {
             max = Math.max(max, zahl);

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/Wuerfel.java

@@ -23,8 +23,8 @@ public class Wuerfel {
      *
      * @param typ Anzahl der Seiten des Würfels.
      */
-    public Wuerfel(WuerfelTyp typ) { 
+    public Wuerfel(WuerfelTyp typ) {
-        this.numSides = typ.getSeiten(); 
+        this.numSides = typ.getSeiten();
     }
 
     /**

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

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

solutions/src/main/java/pr2/enums/eigene/test/WuerfelTest.java

@@ -2,7 +2,7 @@ package pr2.enums.eigene.test;
 
 import org.junit.jupiter.api.Test;
 import pr2.enums.eigene.Wuerfel;
-import pr2.enums.eigene.WuerfelTyp;  
+import pr2.enums.eigene.WuerfelTyp;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 

solutions/src/main/java/pr2/exceptions/eigene_ausnahme/Fuse.java

@@ -32,7 +32,7 @@ public class Fuse {
      * @throws IllegalCurrentException Ausnahme bei einem
      *                                 ungültigen Spannungswert.
      */
-    public Fuse(int tripCurrent) throws IllegalCurrentException { 
+    public Fuse(int tripCurrent) throws IllegalCurrentException {
         switch (tripCurrent) {
             case A16:
             case A25:
@@ -50,7 +50,7 @@ public class Fuse {
      * @param current Strom, der durch die Sicherung fließt.
      * @throws FuseTrippedException wird geworfen, wenn der Srom zu groß wird.
      */
-    public void use(int current) throws FuseTrippedException { 
+    public void use(int current) throws FuseTrippedException {
         if (current > tripCurrent) {
             throw new FuseTrippedException(current, tripCurrent);
         }

solutions/src/main/java/pr2/exceptions/eigene_ausnahme/FuseTrippedException.java

@@ -3,7 +3,7 @@ package pr2.exceptions.eigene_ausnahme;
 /**
  * Ausnahme, wenn die Sicherung auslöst.
  */
-public class FuseTrippedException extends Exception { 
+public class FuseTrippedException extends Exception {
     /**
      * Strom, bei dem die Sicherung ausgelöst hat.
      */

solutions/src/main/java/pr2/exceptions/eigene_ausnahme/IllegalCurrentException.java

@@ -3,7 +3,7 @@ package pr2.exceptions.eigene_ausnahme;
 /**
  * Ausnahme, wenn eine Sicherung angelegt werden soll, die es nicht gibt.
  */
-public class IllegalCurrentException extends Exception { 
+public class IllegalCurrentException extends Exception {
 
     /**
      * Übergebener Strom.

solutions/src/main/java/pr2/exceptions/fakultaet/Fakultaet.java

@@ -2,7 +2,7 @@ package pr2.exceptions.fakultaet;
 
 public class Fakultaet {
 
-    public int fact(int n) throws FakultaetException { 
+    public int fact(int n) throws FakultaetException {
         if (n < 0) {
             throw new FakultaetException("Keine negativen Zahlen!", n);
         }
@@ -13,6 +13,6 @@ public class Fakultaet {
     }
 
     private int factIntern(int n) {
-        return (n == 0) ? 1 : factIntern(n - 1) * n; 
+        return (n == 0) ? 1 : factIntern(n - 1) * n;
     }
 }

solutions/src/main/java/pr2/exceptions/fakultaet/FakultaetException.java

@@ -1,6 +1,6 @@
 package pr2.exceptions.fakultaet;
 
-public class FakultaetException extends Exception { 
+public class FakultaetException extends Exception {
 
     private final int zahl;
 

solutions/src/main/java/pr2/exceptions/fakultaet/test/FakultaetTest.java

@@ -5,12 +5,12 @@ import pr2.exceptions.fakultaet.Fakultaet;
 import pr2.exceptions.fakultaet.FakultaetException;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;  
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class FakultaetTest {
 
     @Test
-    void testFact() throws FakultaetException { 
+    void testFact() throws FakultaetException {
         Fakultaet f = new Fakultaet();
         assertEquals(1, f.fact(0));
         assertEquals(1, f.fact(1));

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();
         }
@@ -33,16 +32,13 @@ public class Buchstabenzaehler {
      * @throws StatistikException Fehler bei der Berechnung der
      *                            Buchstabenhäufigkeit.
      */
-    private void run() throws StatistikException { 
+    private void run() throws StatistikException {
         System.out.print("Bitte geben Sie den Dateinamen an: ");
         Scanner scanner = new Scanner(System.in);
         String dateiname = scanner.nextLine();
 
         int[] statistik;
 
-
-
-
         try {
             statistik = parseFile("assets/" + dateiname);
             printStatistik(statistik);
@@ -64,7 +60,7 @@ public class Buchstabenzaehler {
      * @param statistik Statistik
      * @throws StatistikException Fehler bei den Eingabedaten
      */
-    private void printStatistik(int[] statistik) throws StatistikException { 
+    private void printStatistik(int[] statistik) throws StatistikException {
 
         int summe = 0;
 
@@ -98,8 +94,8 @@ public class Buchstabenzaehler {
      * @throws IOException           generelles IO-Problem
      * @throws FileNotFoundException Datei gibt es nicht
      */
-    private int[] parseFile(String filename)  
+    private int[] parseFile(String filename)
-            throws IOException, FileNotFoundException {  
+            throws IOException, FileNotFoundException {
 
         int[] statistik = new int['z' - 'a' + 1];
 

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/generics/einfach/test/ListeTest.java

@@ -16,7 +16,7 @@ public class ListeTest {
      */
     @Test
     void testAddAndClear() {
-        Liste<String> l = new Liste<>(); 
+        Liste<String> l = new Liste<>();
 
         assertEquals(0, l.size());
 
@@ -37,7 +37,7 @@ public class ListeTest {
      */
     @Test
     void testGet() {
-        Liste<String> l = new Liste<>(); 
+        Liste<String> l = new Liste<>();
         l.add("Hallo");
         l.add("Hugo");
         l.add("Peter");

solutions/src/main/java/pr2/generics/number_pair/NumberPair.java

@@ -1,6 +1,6 @@
 package pr2.generics.number_pair;
 
-public class NumberPair<T extends Number> extends Pair<T, T> { 
+public class NumberPair<T extends Number> extends Pair<T, T> {
 
     public NumberPair(T first, T second) {
         super(first, second);

solutions/src/main/java/pr2/generics/pair/Pair.java

@@ -1,6 +1,6 @@
 package pr2.generics.pair;
 
-public class Pair<T, V> { 
+public class Pair<T, V> {
 
     private final T first;
     private final V second;

solutions/src/main/java/pr2/generics/pairlist/PairList.java

@@ -1,6 +1,6 @@
 package pr2.generics.pairlist;
 
-public class PairList<T, V> { 
+public class PairList<T, V> {
 
     protected final Pair<T, V>[] elements;
     protected int pos;

solutions/src/main/java/pr2/generics/queue/Queue.java

@@ -1,6 +1,6 @@
 package pr2.generics.queue;
 
-public class Queue<T> { 
+public class Queue<T> {
 
     private final T[] elements;
     private int pos = 0;

solutions/src/main/java/pr2/generics/same_pair/SamePair.java

@@ -1,6 +1,6 @@
 package pr2.generics.same_pair;
 
-public class SamePair<T> extends Pair<T, T> { 
+public class SamePair<T> extends Pair<T, T> {
 
     public SamePair(T first, T second) {
         super(first, second);

solutions/src/main/java/pr2/generics/wildcards/Main.java

@@ -32,8 +32,8 @@ public final class Main {
         l2.add(4);
         l2.add(5);
 
-        ListHelper.printList(l1);  
+        ListHelper.printList(l1);
-        ListHelper.printList(l2);  
+        ListHelper.printList(l2);
-        System.out.println(ListHelper.sumList(l2));  
+        System.out.println(ListHelper.sumList(l2));
     }
 }

solutions/src/main/java/pr2/interfaces/abstrakt_form/Form.java

@@ -1,6 +1,6 @@
 package pr2.interfaces.abstrakt_form;
 
-public abstract class Form { 
+public abstract class Form {
 
     protected double x;
     protected double y;

solutions/src/main/java/pr2/interfaces/comparable_student/Student.java

@@ -1,6 +1,6 @@
 package pr2.interfaces.comparable_student;
 
-public class Student implements Comparable { 
+public class Student implements Comparable {
 
     private final String vorname;
     private final String nachname;

solutions/src/main/java/pr2/interfaces/stack/StackImpl.java

@@ -1,6 +1,6 @@
 package pr2.interfaces.stack;
 
-public class StackImpl implements Stack { 
+public class StackImpl implements Stack {
 
     private final Object[] puffer;
     private int pos = -1;

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 {