forked from pr2-lecture/uebungen
Update of exercises
Thomas Smits
parent
b588ff87f2
commit
59dea1a047
|
|
@ -1,6 +1,6 @@
|
|||
# Iterator schreiben
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Für eine gegebene Klasse einen Iterator schreiben.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Iterator schreiben
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.iterator](../../solutions/src/main/java/pr2/collections/iterator/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Iterator programmieren
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Iteratoren verstehen und programmieren.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Iterator programmieren
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.list_iterator](../../solutions/src/main/java/pr2/collections/list_iterator/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# `List<T>` und dessen Implementierungen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Das Interface `List<T>` und eine passende Implementierung einsetzen.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: `List<T>` und dessen Implementierungen
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.list](../../solutions/src/main/java/pr2/collections/list/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# `Map<T>` verwenden
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Das Interface `Map<T>` und seine Implementierungen verwenden, um Daten effizient zu verarbeiten.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: `Map<T>` verwenden
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.map](../../solutions/src/main/java/pr2/collections/map/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# ReverserGeneric
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
`Comparable` verstehen und nutzen.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: ReverserGeneric
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.reverser_generic](../../solutions/src/main/java/pr2/collections/reverser_generic/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Strings umgekehrt sortieren: Reverser
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
`Comparable` verstehen und nutzen.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Strings umgekehrt sortieren: Reverser
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.reverser](../../solutions/src/main/java/pr2/collections/reverser/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# `Set<T>` und dessen Implementierungen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Das Interface `Set<T>` und eine passende Implementierung einsetzen.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: `Set<T>` und dessen Implementierungen
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.set](../../solutions/src/main/java/pr2/collections/set/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# CommandLineSorter
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Sortieren von Collections.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: CommandLineSorter
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.sorter_1](../../solutions/src/main/java/pr2/collections/sorter_1/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# CommandLineSorter -- Version 2
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Sortieren von Collections.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: CommandLineSorter -- Version 2
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.sorter_2](../../solutions/src/main/java/pr2/collections/sorter_2/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# `Comparator<T>` verwenden und Objekte sortieren
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Verschiedene Sortierreihenfolgen durch die Implementierung von `Comparator<T>` realisieren.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: `Comparator<T>` verwenden und Objekte sortieren
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.sortieren](../../solutions/src/main/java/pr2/collections/sortieren/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Wörterbuchprogramm
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Interface `Map` und seine Implementierungen einsetzen.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Wörterbuchprogramm
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.collections.woerterbuch](../../solutions/src/main/java/pr2/collections/woerterbuch/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Kleinbuchstaben in einem String zählen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Streams verwenden.
|
||||
|
|
|
|||
|
|
@ -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/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Buchstaben in einer Liste von Strings zählen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Streams verwenden.
|
||||
|
|
|
|||
|
|
@ -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/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Kleinbuchstaben in einem String zählen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Streams verwenden.
|
||||
|
|
|
|||
|
|
@ -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/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Liste filtern
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Daten in Streams filtern.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Liste filtern
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.streams.filter](../.. /solutions/src/main/java/pr2/streams/filter/)
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Streams mit interner Iteration
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.streams.interne_iteration](../../solutions/src/main/java/pr2/streams/interne_iteration/)
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Map und Reduce auf Streams
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Die Daten in einem Stream durch Map- und Reduce verdichten.
|
||||
|
|
|
|||
|
|
@ -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/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Reduce
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Daten in Streams mit `reduce` aggregieren.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Reduce
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.streams.reduce](../../solutions/src/main/java/pr2/streams/reduce/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Summe über reduce bestimmen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Daten in Streams mit `reduce` aggregieren.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Summe über reduce bestimmen
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.streams.summieren](../../solutions/src/main/java/pr2/streams/summieren/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Wörter zählen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Daten in Streams mit `reduce` aggregieren.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Wörter zählen
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.streams.word_count](../../solutions/src/main/java/pr2/streams/word_count/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Fakultät parallel berechnen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Berechnungen parallelisieren.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Fakultät parallel berechnen
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.threads.fakultaet](../../solutions/src/main/java/pr2/threads/fakultaet/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Thread per interrupt beenden
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Threads kontrolliert beenden.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Thread per interrupt beenden
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.threads.interrupt](../../solutions/src/main/java/pr2/threads/interrupt/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# wait und notify benutzen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Thread-Koordination über Condition-Variablen.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: wait und notify benutzen
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.threads.notifier](../../solutions/src/main/java/pr2/threads/notifier/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Parallele Ausgaben erzeugen
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Erste Schritte mit Threads.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Parallele Ausgaben erzeugen
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.threads.paralleldrucker](../../solutions/src/main/java/pr2/threads/paralleldrucker/)
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Stack und Heap unterscheiden
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Unterschied zwischen Stack und Heap bei parallelen Programmen verstehen.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Stack und Heap unterscheiden
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.threads.stack_heap](../../solutions/src/main/java/pr2/threads/stack_heap/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# synchronized verwenden
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Schlüsselwort `synchronized` verwenden.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: synchronized verwenden
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.threads.synchronize](../../solutions/src/main/java/pr2/threads/synchronize/)
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# Timer und TimerTask verwenden
|
||||
## Lernziel
|
||||
|
||||
[Musterlösung](solution/)
|
||||
|
||||
|
||||
Klassen aus `java.util.concurrent` verwenden.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
# Lösung: Timer und TimerTask verwenden
|
||||
|
||||
Musterlösung:
|
||||
|
||||
[pr2.threads.timer](../../solutions/src/main/java/pr2/threads/timer/)
|
||||
58
readme.md
58
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) | |
|
||||
| 80. | Collections | [Iterator programmieren](Collections_002/readme.md) | |
|
||||
| 81. | Collections | [`List<T>` und dessen Implementierungen](Collections_003/readme.md) | |
|
||||
| 82. | Collections | [`Map<T>` verwenden](Collections_004/readme.md) | |
|
||||
| 83. | Collections | [ReverserGeneric](Collections_005/readme.md) | |
|
||||
| 84. | Collections | [Strings umgekehrt sortieren: Reverser](Collections_006/readme.md) | |
|
||||
| 85. | Collections | [`Set<T>` und dessen Implementierungen](Collections_007/readme.md) | |
|
||||
| 86. | Collections | [CommandLineSorter](Collections_008/readme.md) | |
|
||||
| 87. | Collections | [CommandLineSorter -- Version 2](Collections_009/readme.md) | |
|
||||
| 88. | Collections | [`Comparator<T>` verwenden und Objekte sortieren](Collections_010/readme.md) | |
|
||||
| 89. | Collections | [Wörterbuchprogramm](Collections_011/readme.md) | |
|
||||
| 90. | Streams | [Kleinbuchstaben in einem String zählen](Streams_001/readme.md) | |
|
||||
| 91. | Streams | [Buchstaben in einer Liste von Strings zählen](Streams_002/readme.md) | |
|
||||
| 92. | Streams | [Kleinbuchstaben in einem String zählen](Streams_003/readme.md) | |
|
||||
| 93. | Streams | [Liste filtern](Streams_004/readme.md) | |
|
||||
| 94. | Streams | [Streams mit interner Iteration](Streams_005/readme.md) | |
|
||||
| 95. | Streams | [Map und Filter auf Streams](Streams_006/readme.md) | |
|
||||
| 96. | Streams | [Map und Reduce auf Streams](Streams_007/readme.md) | |
|
||||
| 97. | Streams | [Reduce](Streams_008/readme.md) | |
|
||||
| 98. | Streams | [Summe über reduce bestimmen](Streams_009/readme.md) | |
|
||||
| 99. | Streams | [Wörter zählen](Streams_010/readme.md) | |
|
||||
| 100. | Threads | [Fakultät parallel berechnen](Threads_001/readme.md) | |
|
||||
| 101. | Threads | [Thread per interrupt beenden](Threads_002/readme.md) | |
|
||||
| 102. | Threads | [wait und notify benutzen](Threads_003/readme.md) | |
|
||||
| 103. | Threads | [Parallele Ausgaben erzeugen](Threads_004/readme.md) | |
|
||||
| 104. | Threads | [Race-Condition finden und beheben](Threads_005/readme.md) | |
|
||||
| 105. | Threads | [Stack und Heap unterscheiden](Threads_006/readme.md) | |
|
||||
| 106. | Threads | [synchronized verwenden](Threads_007/readme.md) | |
|
||||
| 107. | Threads | [Timer und TimerTask verwenden](Threads_008/readme.md) | |
|
||||
| 79. | Collections | [Iterator schreiben](Collections_001/readme.md) | [✅](Collections_001/solution/) |
|
||||
| 80. | Collections | [Iterator programmieren](Collections_002/readme.md) | [✅](Collections_002/solution/) |
|
||||
| 81. | Collections | [`List<T>` und dessen Implementierungen](Collections_003/readme.md) | [✅](Collections_003/solution/) |
|
||||
| 82. | Collections | [`Map<T>` verwenden](Collections_004/readme.md) | [✅](Collections_004/solution/) |
|
||||
| 83. | Collections | [ReverserGeneric](Collections_005/readme.md) | [✅](Collections_005/solution/) |
|
||||
| 84. | Collections | [Strings umgekehrt sortieren: Reverser](Collections_006/readme.md) | [✅](Collections_006/solution/) |
|
||||
| 85. | Collections | [`Set<T>` und dessen Implementierungen](Collections_007/readme.md) | [✅](Collections_007/solution/) |
|
||||
| 86. | Collections | [CommandLineSorter](Collections_008/readme.md) | [✅](Collections_008/solution/) |
|
||||
| 87. | Collections | [CommandLineSorter -- Version 2](Collections_009/readme.md) | [✅](Collections_009/solution/) |
|
||||
| 88. | Collections | [`Comparator<T>` verwenden und Objekte sortieren](Collections_010/readme.md) | [✅](Collections_010/solution/) |
|
||||
| 89. | Collections | [Wörterbuchprogramm](Collections_011/readme.md) | [✅](Collections_011/solution/) |
|
||||
| 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) | [✅](Streams_002/solution/) |
|
||||
| 92. | Streams | [Kleinbuchstaben in einem String zählen](Streams_003/readme.md) | [✅](Streams_003/solution/) |
|
||||
| 93. | Streams | [Liste filtern](Streams_004/readme.md) | [✅](Streams_004/solution/) |
|
||||
| 94. | Streams | [Streams mit interner Iteration](Streams_005/readme.md) | [✅](Streams_005/solution/) |
|
||||
| 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) | [✅](Streams_007/solution/) |
|
||||
| 97. | Streams | [Reduce](Streams_008/readme.md) | [✅](Streams_008/solution/) |
|
||||
| 98. | Streams | [Summe über reduce bestimmen](Streams_009/readme.md) | [✅](Streams_009/solution/) |
|
||||
| 99. | Streams | [Wörter zählen](Streams_010/readme.md) | [✅](Streams_010/solution/) |
|
||||
| 100. | Threads | [Fakultät parallel berechnen](Threads_001/readme.md) | [✅](Threads_001/solution/) |
|
||||
| 101. | Threads | [Thread per interrupt beenden](Threads_002/readme.md) | [✅](Threads_002/solution/) |
|
||||
| 102. | Threads | [wait und notify benutzen](Threads_003/readme.md) | [✅](Threads_003/solution/) |
|
||||
| 103. | Threads | [Parallele Ausgaben erzeugen](Threads_004/readme.md) | [✅](Threads_004/solution/) |
|
||||
| 104. | Threads | [Race-Condition finden und beheben](Threads_005/readme.md) | [✅](Threads_005/solution/) |
|
||||
| 105. | Threads | [Stack und Heap unterscheiden](Threads_006/readme.md) | [✅](Threads_006/solution/) |
|
||||
| 106. | Threads | [synchronized verwenden](Threads_007/readme.md) | [✅](Threads_007/solution/) |
|
||||
| 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) | |
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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--];
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -23,8 +23,8 @@ public class Wuerfel {
|
|||
*
|
||||
* @param typ Anzahl der Seiten des Würfels.
|
||||
*/
|
||||
public Wuerfel(WuerfelTyp typ) {
|
||||
this.numSides = typ.getSeiten();
|
||||
public Wuerfel(WuerfelTyp typ) {
|
||||
this.numSides = typ.getSeiten();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
package pr2.enums.eigene;
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
package pr2.exceptions.fakultaet;
|
||||
|
||||
public class FakultaetException extends Exception {
|
||||
public class FakultaetException extends Exception {
|
||||
|
||||
private final int zahl;
|
||||
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
throws IOException, FileNotFoundException {
|
||||
private int[] parseFile(String filename)
|
||||
throws IOException, FileNotFoundException {
|
||||
|
||||
int[] statistik = new int['z' - 'a' + 1];
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@ package pr2.generics.einfach;
|
|||
*
|
||||
* @param <T> Typ der gespeicherten Objekte
|
||||
*/
|
||||
|
||||
public class Liste<T> {
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
package pr2.generics.einfach;
|
||||
|
||||
|
||||
/**
|
||||
* Interne Repräsentation der Knoten in der Liste.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
package pr2.generics.queue;
|
||||
|
||||
public class Queue<T> {
|
||||
public class Queue<T> {
|
||||
|
||||
private final T[] elements;
|
||||
private int pos = 0;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -32,8 +32,8 @@ public final class Main {
|
|||
l2.add(4);
|
||||
l2.add(5);
|
||||
|
||||
ListHelper.printList(l1);
|
||||
ListHelper.printList(l2);
|
||||
System.out.println(ListHelper.sumList(l2));
|
||||
ListHelper.printList(l1);
|
||||
ListHelper.printList(l2);
|
||||
System.out.println(ListHelper.sumList(l2));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
package pr2.interfaces.abstrakt_form;
|
||||
|
||||
public abstract class Form {
|
||||
public abstract class Form {
|
||||
|
||||
protected double x;
|
||||
protected double y;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
package pr2.interfaces.uebersetzer;
|
||||
|
||||
public class Translator {
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
package pr2.interfaces.uebersetzer;
|
||||
|
||||
public class UebersetzerDeutschEnglisch implements Uebersetzer {
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue