Update of exercises
Thomas Smits
parent
5c448e64bd
commit
5150715f8d
|
|
@ -0,0 +1,29 @@
|
|||
# Iterator schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Für eine gegebene Klasse einen Iterator schreiben.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.iterator](../sources/src/main/java/pr2/collections/iterator/).
|
||||
|
||||
In dieser Aufgabe sollen Sie für eine bereits vorhandene Klasse einen Iterator schreiben. Bei dieser Klasse (`SimpleStack`) handelt es sich um einen sehr einfach (und nicht sehr sicher) programmierten Stack.
|
||||
|
||||
Implementieren Sie in `SimpleStack<T>` das Interface `Iterable<T>` und schreiben Sie, wie vom Interface verlangt einen Iterator für die Klasse. Sie sollten hier innere Klasse verwenden, um den Zugriff auf die privaten Attribute von `SimpleStack` zu vereinfachen.
|
||||
|
||||
Benutzen Sie die Tests in `SimpleStackTest`, um zu überprüfen, dass Ihre Implementierung des Iterators richtig funktioniert. Hierzu müssen Sie die entsprechenden Tests allerdings erst einkommentieren.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# mithilfe eines Iterators über Daten iterieren
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Den Iterator einer vorhandenen Klasse verwenden, um Daten auszulesen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.iterieren](../sources/src/main/java/pr2/collections/iterieren/).
|
||||
|
||||
Bei dieser Aufgabe werden Sie mit einem `Iterator` über eine Menge von Objekten iterieren. Die Besonderheit besteht darin, dass der Iterator keine feste Menge von Objekten liefert, sondern diese zufällig generiert. Dies ist zwar ungewöhnlich, soll aber zeigen, dass beim Iterieren nicht zwangsläufig bei jedem Durchlauf dieselben Daten kommen.
|
||||
|
||||
Betrachten Sie die Klasse `CoinGenerator` und versuchen Sie deren Funktionsweise zu verstehen. Schauen Sie sich insbesondere an, wie der Iterator in dieser Klasse implementiert ist.
|
||||
|
||||
Modifizieren Sie nun die Klasse `GameBoard` so, dass sie den `CoinGenerator` verwendet, um Münzen zu erzeugen und diese dann auf dem Bildschirm anzuzeigen. Überlegen Sie sich, ob Sie die erzeugten Münzen zwischenspeichern müssen oder ob Sie den Iterator direkt in der `drawGame`-Methode verwenden können.
|
||||
|
||||
Implementieren Sie Ihre Lösung und lassen Sie diese laufen, um sie zu testen.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# Iterator programmieren
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Iteratoren verstehen und programmieren.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Im Paket [pr2.collections.list_iterator](../sources/src/main/java/pr2/collections/list_iterator/) finden Sie den Code für eine einfach verkettete Liste `Liste<T>`.
|
||||
|
||||
Geben Sie bitte den fehlenden Code für die innere Klasse `ListenIterator` an.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# `List<T>` und dessen Implementierungen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Das Interface `List<T>` und eine passende Implementierung einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.list](../sources/src/main/java/pr2/collections/list/).
|
||||
|
||||
Im Projekt finden Sie die Klasse `WordCollector` mit deren Hilfe man die Wörter in einem Text analysieren kann. Nach Übergabe eines Dateinamens wird die Datei eingelesen und die vorhandenen Wörter werden gesammelt. Am Ende wird die Liste der Wörter alphabetisch sortiert ausgegeben.
|
||||
|
||||
Leider wurde `WordCollector` von einem Entwickler geschrieben, der nichts von dem Collection-Framework wusste und daher alles mit Array realisiert hat. Hierdurch sind einige sehr komplexe Konstruktionen entstanden.
|
||||
|
||||
Lassen Sie das Programm laufen und betrachten Sie die Ausgabe. Schauen Sie sich die Klasse `WordCollector` an und versuchen Sie die Funktionsweise und die Implementierung genau zu verstehen. Dieser Schritt ist wichtig, um die im Folgenden beschriebenen Änderungen an der Klasse vornehmen zu können, lassen Sie sich also Zeit für diesen Schritt.
|
||||
|
||||
Ändern Sie die Klasse nun so, dass anstatt Arrays `List<T>` und deren Implementierungen verwendet werden. Ändern Sie die Schnittstellen und Parameter der Methoden von `String[]` auf `List<String>`. Modifizieren Sie auch die Implementierung der Methoden und versuchen Sie Arrays wo immer möglich durch Listen zu ersetzen. Schauen Sie sich auch die JavaDoc der Klassen `java.util.Arrays` und `java.util.Collections` an, um möglicherweise sehr hilfreiche Methoden zu finden.
|
||||
|
||||
__Hinweis:__ Die Konstruktion `String[] words = line.toLowerCase().split("[,. ]");` können Sie nicht durch Listen ersetzen, da die `split`-Methode Arrays verwendet.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
# `Map<T>` verwenden
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Das Interface `Map<T>` und seine Implementierungen verwenden, um Daten effizient zu verarbeiten.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.map](../sources/src/main/java/pr2/collections/map/).
|
||||
|
||||
In dieser Aufgabe geht es darum, die Häufigkeit von Wörtern in einem Text zu analysieren. Ein grundlegendes Gerüst für das Programm ist auch bereits vorgegeben, damit Sie sich auf das Wesentliche konzentrieren können.
|
||||
|
||||
Betrachten Sie die Klasse `WordCount`. In dieser fehlen noch einige Elemente, damit das Programm korrekt funktionieren kann.
|
||||
|
||||
Die innere Klasse `WordFrequency` muss das Sortieren unterstützen. Implementieren Sie daher das Interface `Comparable`.
|
||||
|
||||
Fügen Sie in der Klasse `WordCount` an den durch TODO-Kommentare markierten Stellen Code hinzu, der mithilfe einer Map die Worthäufigkeiten bestimmt.
|
||||
|
||||
Lassen Sie das Programm laufen. Es sollte eine Ausgabe wie folgt erzeugen:
|
||||
|
||||
```console
|
||||
er: 80
|
||||
sie: 66
|
||||
und: 64
|
||||
die: 59
|
||||
der: 51
|
||||
zu: 46
|
||||
es: 45
|
||||
nicht: 41
|
||||
das: 38
|
||||
in: 35
|
||||
...
|
||||
```
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# ReverserGeneric
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
`Comparable` verstehen und nutzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.reverser_generic](../sources/src/main/java/pr2/collections/reverser_generic/).
|
||||
|
||||
Schreiben Sie bitte eine generische Klasse `Reverser` mit einer Methode `reverse`, der man eine Liste (`java.util.List`) von Objekten übergeben kann und diese absteigend sortiert wird. Stellen Sie durch korrekte Wahl des Typ-Parameters sicher, dass die in der Liste gespeicherten Objekte das Interface `Comparable` implementieren.
|
||||
|
||||
Testen Sie Ihre Implementierung mit der Klasse `ReverserTest`.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# Strings umgekehrt sortieren: Reverser
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
`Comparable` verstehen und nutzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.reverser](../sources/src/main/java/pr2/collections/reverser/).
|
||||
|
||||
Schreiben Sie bitte eine Klasse `Reverser` mit einer Methode `reverse`, der man eine Liste (`java.util.List`) von `String` übergeben kann und die diese dann absteigend sortiert, d.h. als Erstes kommen die Einträge mit Z, dann die mit Y etc.
|
||||
|
||||
Testen Sie Ihre Implementierung mit der Klasse `ReverserTest`.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# `Set<T>` und dessen Implementierungen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Das Interface `Set<T>` und eine passende Implementierung einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.set](../sources/src/main/java/pr2/collections/set/).
|
||||
|
||||
Im Projekt finden Sie die Klasse `WordCollector` mit deren Hilfe man die Wörter in einem Text analysieren kann. Nach Übergabe eines Dateinamens wird die Datei eingelesen und die vorhandenen Wörter werden gesammelt. Am Ende wird die Liste der Wörter alphabetisch sortiert ausgegeben.
|
||||
|
||||
Leider wurde `WordCollector` von einem Entwickler geschrieben, der nichts von dem Collection-Framework wusste und daher alles mit Array realisiert hat. Hierdurch sind einige sehr komplexe Konstruktionen entstanden.
|
||||
|
||||
Lassen Sie das Programm laufen und betrachten Sie die Ausgabe. Schauen Sie sich die Klasse `WordCollector` an und versuchen Sie die Funktionsweise und die Implementierung genau zu verstehen. Dieser Schritt ist wichtig, um die im Folgenden beschriebenen Änderungen an der Klasse vornehmen zu können, lassen Sie sich also Zeit für diesen Schritt.
|
||||
|
||||
Ändern Sie die Klasse nun so, dass anstatt Arrays `Set<T>` und deren Implementierungen verwendet werden. Ändern Sie die Schnittstellen und Parameter der Methoden von `String[]` auf `Set<String>` bzw. `List<String>`. Modifizieren Sie auch die Implementierung der Methoden und versuchen Sie Arrays wo immer möglich durch Sets und Listen zu ersetzen. Schauen Sie sich auch die JavaDoc der Klassen `java.util.Arrays` und `java.util.Collections` an, um möglicherweise sehr hilfreiche Methoden zu finden.
|
||||
|
||||
__Hinweis:__ Die Konstruktion `String[] words = line.toLowerCase().split("[,. ]");` können Sie nicht durch Listen ersetzen, da die `split`-Methode Arrays verwendet.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
# CommandLineSorter
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Sortieren von Collections.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.sorter_1](../sources/src/main/java/pr2/collections/sorter_1/).
|
||||
|
||||
Schreiben Sie bitte eine Klasse `CommandLineSorter`, die eine Reihe von Wörtern auf der Kommandozeile als Parameter annimmt und diese dann alphabetisch sortiert wieder ausgibt.
|
||||
|
||||
```console
|
||||
> java CommandLineSorter Albert Dieter Sigmund Thomas Frank Dieter Herbert
|
||||
Albert
|
||||
Dieter
|
||||
Dieter
|
||||
Frank
|
||||
Herbert
|
||||
Sigmund
|
||||
Thomas
|
||||
```
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# CommandLineSorter -- Version 2
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Sortieren von Collections.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.sorter_2](../sources/src/main/java/pr2/collections/sorter_2/).
|
||||
|
||||
Schreiben Sie bitte eine Klasse `CommandLineSorter`, die eine Reihe von Wörtern auf der Kommandozeile als Parameter annimmt und diese dann alphabetisch sortiert wieder ausgibt. Hierbei sollen alle Dubletten entfernt werden, d.h. es soll kein Wort doppelt in der Liste auftauchen.
|
||||
|
||||
```console
|
||||
> java CommandLineSorter Albert Dieter Sigmund Dieter Thomas Frank Herbert
|
||||
Albert
|
||||
Dieter
|
||||
Frank
|
||||
Herbert
|
||||
Sigmund
|
||||
Thomas
|
||||
```
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# `Comparator<T>` verwenden und Objekte sortieren
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Verschiedene Sortierreihenfolgen durch die Implementierung von `Comparator<T>` realisieren.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.sortieren](../sources/src/main/java/pr2/collections/sortieren/).
|
||||
|
||||
Sie finden in der Aufgabe bereits die Klasse `Sorter` und den JUnit-Test `SorterTest` vor. Schauen Sie sich die Klasse `Sorter` an und versuchen Sie anhand der JavaDoc und des bereits vorhandenen Codes zu verstehen, was die Klasse machen soll.
|
||||
|
||||
Lassen Sie den Test laufen. Sie werden feststellen, dass ein Testfall grün ist, obwohl in `Sorter` gar keine Implementierung vorhanden ist. Versuchen Sie herauszufinden, warum dies so ist.
|
||||
|
||||
Fügen Sie nun den fehlenden Code in die Klasse `Sorter` ein, und geben Sie entsprechende `Comparator`-Objekte zurück, sodass die Daten entsprechend dem Parameter `order` sortiert werden können.
|
||||
|
||||
Lassen Sie erneut die Tests laufen. Es müssen alle Testfälle grün sein, bevor Sie die Lösung einchecken.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
# Wörterbuchprogramm
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Interface `Map` und seine Implementierungen einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.collections.woerterbuch](../sources/src/main/java/pr2/collections/woerterbuch/).
|
||||
|
||||
Schreiben Sie ein einfaches Wörterbuchprogramm, dem man auf der Kommandozeile eine beliebige Anzahl von Wörtern übergeben kann und das dann die entsprechende Übersetzung ausgibt. Die Wörter des Wörterbuchs sollen fest im Programm einprogrammiert sein. Es reicht, wenn Sie einige wenige Wörter vorsehen.
|
||||
|
||||
Berücksichtigen Sie bitte den Fall, dass der Benutzer kein Wort auf der Kommandozeile angibt bzw. dass ein Wort nicht im Wörterbuch vorhanden ist.
|
||||
|
||||
```console
|
||||
> java Woerterbuch
|
||||
Bitte mindestens ein Wort angeben!
|
||||
```
|
||||
|
||||
```console
|
||||
>java Woerterbuch gehen schlafen tanzen hopsen
|
||||
gehen => go
|
||||
schlafen => sleep
|
||||
tanzen => dance
|
||||
hopsen => <unbekanntes Wort>
|
||||
```
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
12
readme.md
12
readme.md
|
|
@ -93,3 +93,15 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
|
|||
| 83. | 05.06.2023 | [StringTransmogrifier erweitern](Assignment_083/readme.md) |
|
||||
| 84. | 05.06.2023 | [Nonstatic Member Class](Assignment_084/readme.md) |
|
||||
| 85. | 05.06.2023 | [Static Member Class](Assignment_085/readme.md) |
|
||||
| 86. | 01.01.2023 | [Iterator schreiben](Assignment_086/readme.md) |
|
||||
| 87. | 01.01.2023 | [mithilfe eines Iterators über Daten iterieren](Assignment_087/readme.md) |
|
||||
| 88. | 01.01.2023 | [Iterator programmieren](Assignment_088/readme.md) |
|
||||
| 89. | 01.01.2023 | [`List<T>` und dessen Implementierungen](Assignment_089/readme.md) |
|
||||
| 90. | 01.01.2023 | [`Map<T>` verwenden](Assignment_090/readme.md) |
|
||||
| 91. | 01.01.2023 | [ReverserGeneric](Assignment_091/readme.md) |
|
||||
| 92. | 01.01.2023 | [Strings umgekehrt sortieren: Reverser](Assignment_092/readme.md) |
|
||||
| 93. | 01.01.2023 | [`Set<T>` und dessen Implementierungen](Assignment_093/readme.md) |
|
||||
| 94. | 01.01.2023 | [CommandLineSorter](Assignment_094/readme.md) |
|
||||
| 95. | 01.01.2023 | [CommandLineSorter -- Version 2](Assignment_095/readme.md) |
|
||||
| 96. | 01.01.2023 | [`Comparator<T>` verwenden und Objekte sortieren](Assignment_096/readme.md) |
|
||||
| 97. | 01.01.2023 | [Wörterbuchprogramm](Assignment_097/readme.md) |
|
||||
|
|
|
|||
|
|
@ -0,0 +1,56 @@
|
|||
package pr2.collections.iterator;
|
||||
|
||||
import java.util.Iterator;
|
||||
|
||||
/**
|
||||
* Eine einfache, naive Stack Implementierung.
|
||||
*
|
||||
* @param <T> Typ, der gespeichert werden soll.
|
||||
*/
|
||||
public class SimpleStack<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];
|
||||
}
|
||||
|
||||
// TODO: Interface Iterable<T> implementieren
|
||||
}
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
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());
|
||||
}
|
||||
|
||||
// TODO: Einkommentieren
|
||||
//
|
||||
// /**
|
||||
// * 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,115 @@
|
|||
package pr2.collections.iterieren;
|
||||
|
||||
import de.smits_net.games.framework.board.Board;
|
||||
import de.smits_net.games.framework.image.SimpleImage;
|
||||
import de.smits_net.games.framework.sprite.Sprite;
|
||||
import de.smits_net.games.framework.sprite.Sprite.BoundaryPolicy;
|
||||
|
||||
import java.awt.Point;
|
||||
import java.util.Iterator;
|
||||
import java.util.Random;
|
||||
|
||||
/**
|
||||
* Klasse, die eine beliebige Menge an Geld generiert.
|
||||
*/
|
||||
public class CoinGenerator implements Iterable<Sprite> {
|
||||
|
||||
/**
|
||||
* Zufallszahlen-Generator.
|
||||
*/
|
||||
private static final Random RND = new Random();
|
||||
|
||||
/**
|
||||
* Das Spielfeld.
|
||||
*/
|
||||
private final Board board;
|
||||
|
||||
/**
|
||||
* Anzahl der Münzen, die erzeugt werden sollen.
|
||||
*/
|
||||
int number; // nicht private wegen innerer Klasse
|
||||
|
||||
/**
|
||||
* Erzeugt eine neue Instanz, die zu dem übergebenen Spielfeld gehört.
|
||||
*
|
||||
* @param board Das Spielfeld.
|
||||
* @param number Anzahl der Münzen.
|
||||
*/
|
||||
public CoinGenerator(Board board, int number) {
|
||||
this.board = board;
|
||||
this.number = number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Erzeugt einen neuen Iterator.
|
||||
*
|
||||
* @return Der Iterator.
|
||||
*/
|
||||
@Override
|
||||
public Iterator<Sprite> iterator() {
|
||||
return new Iterator<Sprite>() {
|
||||
|
||||
int count = 0;
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return count < number;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Sprite next() {
|
||||
count++;
|
||||
return createCoin();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Legt eine zufällige Münze an.
|
||||
*
|
||||
* @return die Münze als Sprite.
|
||||
*/
|
||||
Sprite createCoin() {
|
||||
final String prefix = "pr2/collections/iterieren";
|
||||
|
||||
String asset;
|
||||
|
||||
switch (RND.nextInt(8)) {
|
||||
case 0:
|
||||
asset = prefix + "/1c.png";
|
||||
break;
|
||||
case 1:
|
||||
asset = prefix + "/2c.png";
|
||||
break;
|
||||
case 3:
|
||||
asset = prefix + "/5c.png";
|
||||
break;
|
||||
case 4:
|
||||
asset = prefix + "/10c.png";
|
||||
break;
|
||||
case 5:
|
||||
asset = prefix + "/20c.png";
|
||||
break;
|
||||
case 6:
|
||||
asset = prefix + "/50c.png";
|
||||
break;
|
||||
case 7:
|
||||
asset = prefix + "/1e.png";
|
||||
break;
|
||||
default:
|
||||
asset = prefix + "/2e.png";
|
||||
break;
|
||||
}
|
||||
|
||||
int xPos = RND.nextInt(board.getWidth()) - 20;
|
||||
int yPos = RND.nextInt(board.getHeight()) - 20;
|
||||
|
||||
return new Sprite(board, new Point(xPos, yPos), BoundaryPolicy.NONE,
|
||||
new SimpleImage(asset)) {
|
||||
@Override
|
||||
protected void mousePressed() {
|
||||
this.setVisible(false);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
package pr2.collections.iterieren;
|
||||
|
||||
import de.smits_net.games.framework.board.Board;
|
||||
import de.smits_net.games.framework.sprite.Sprite;
|
||||
|
||||
import java.awt.Color;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.Graphics;
|
||||
import java.util.Iterator;
|
||||
|
||||
/**
|
||||
* Spielfeld.
|
||||
*/
|
||||
public class GameBoard extends Board {
|
||||
|
||||
/**
|
||||
* Anzahl der Münzen.
|
||||
*/
|
||||
private static final int NUM_COINS = 1000;
|
||||
|
||||
/**
|
||||
* Münzgenerator.
|
||||
*/
|
||||
private final CoinGenerator generator;
|
||||
|
||||
/**
|
||||
* Münzen auf dem Spielfeld.
|
||||
*/
|
||||
private final Sprite[] coins = new Sprite[NUM_COINS];
|
||||
|
||||
/**
|
||||
* Erzeugt ein neues Board.
|
||||
*/
|
||||
public GameBoard() {
|
||||
// neues Spielfeld anlegen
|
||||
super(10, new Dimension(600, 600), Color.BLACK);
|
||||
|
||||
generator = new CoinGenerator(this, NUM_COINS);
|
||||
|
||||
// TODO: Münzen generieren
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Spielfeld neu zeichnen. Wird vom Framework aufgerufen.
|
||||
*/
|
||||
@Override
|
||||
public synchronized void drawGame(Graphics g) {
|
||||
// TODO: Münzen zeichnen
|
||||
}
|
||||
|
||||
/**
|
||||
* Spielsituation updaten. Wird vom Framework aufgerufen.
|
||||
*/
|
||||
@Override
|
||||
public boolean updateGame() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
package pr2.collections.iterieren;
|
||||
|
||||
import de.smits_net.games.framework.board.MainWindow;
|
||||
|
||||
import java.awt.EventQueue;
|
||||
|
||||
/**
|
||||
* Hauptklasse des Spiels.
|
||||
*/
|
||||
public class GameMain extends MainWindow {
|
||||
|
||||
/**
|
||||
* Neues Spiel anlegen.
|
||||
*/
|
||||
public GameMain() {
|
||||
super("Click the coins as fast as you can", new GameBoard());
|
||||
}
|
||||
|
||||
/**
|
||||
* Startpunkt.
|
||||
*
|
||||
* @param args command line arguments.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
// Spiel starten
|
||||
EventQueue.invokeLater(GameMain::new);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
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 Wort
|
||||
* @throws IOException Fehler beim Dateizugriff.
|
||||
*/
|
||||
public static String[] listWords(String filename) throws IOException {
|
||||
String[] allWords = readFileAndSplitIntoWords(filename);
|
||||
String[] result = removeDuplicates(allWords);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listet alle Worte in der Datei auf.
|
||||
*
|
||||
* @param filename Dateiname
|
||||
* @return die Liste der vorhandenen Wort
|
||||
* @throws IOException Fehler beim Dateizugriff.
|
||||
*/
|
||||
private static String[] readFileAndSplitIntoWords(String filename)
|
||||
throws IOException {
|
||||
|
||||
// Datei zum Lesen öffnen
|
||||
BufferedReader reader = new BufferedReader(
|
||||
new FileReader(filename));
|
||||
|
||||
String line; // aktuelle Zeile
|
||||
String[] wordBuffer = new String[100]; // Puffer für die Worte
|
||||
int pos = 0; // Position im Word-Puffer
|
||||
|
||||
// Ü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
|
||||
for (String word : words) {
|
||||
|
||||
if (pos >= wordBuffer.length) {
|
||||
// Puffer ist voll, vergrößern
|
||||
String[] newBuffer =
|
||||
new String[wordBuffer.length * 2];
|
||||
System.arraycopy(wordBuffer, 0, newBuffer,
|
||||
0, wordBuffer.length);
|
||||
wordBuffer = newBuffer;
|
||||
}
|
||||
|
||||
wordBuffer[pos++] = word;
|
||||
}
|
||||
}
|
||||
|
||||
reader.close();
|
||||
|
||||
// Ergebnis-Array mit der richtigen Größe anlegen
|
||||
String[] result = new String[pos];
|
||||
System.arraycopy(wordBuffer, 0, result, 0, pos);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sortiert das übergebene Array alphabetisch und entfernt Duplikate.
|
||||
*
|
||||
* @param input Eingabe Array
|
||||
* @return sortiertes und bereinigtes Array
|
||||
*/
|
||||
private static String[] removeDuplicates(String[] input) {
|
||||
|
||||
// Eingabe Array clonen, da es verändert wird (Seiteneffekt)
|
||||
String[] strings = input.clone();
|
||||
|
||||
// Array sortieren
|
||||
Arrays.sort(strings);
|
||||
|
||||
// Über die Einträge laufen
|
||||
for (int i = 0; i < strings.length; i++) {
|
||||
String word = strings[i];
|
||||
|
||||
if (word == null) {
|
||||
// Bereits entfernter Eintrag
|
||||
continue;
|
||||
}
|
||||
|
||||
// Über die Einträge laufen
|
||||
for (int k = i + 1; k < strings.length; k++) {
|
||||
String otherWord = strings[k];
|
||||
|
||||
if (otherWord == null) {
|
||||
// Bereits entfernter Eintrag
|
||||
continue;
|
||||
}
|
||||
else if (otherWord.compareTo(word) > 0) {
|
||||
// Sind schon hinter der möglichen Position
|
||||
break;
|
||||
}
|
||||
else if (otherWord.equals(word)) {
|
||||
// Duplikat, ausnullen
|
||||
strings[k] = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Ausgenullte Einträge entfernen
|
||||
int pos = 0;
|
||||
String[] temp = new String[strings.length];
|
||||
|
||||
for (int i = 0; i < strings.length; i++) {
|
||||
if (strings[i] != null) {
|
||||
temp[pos++] = strings[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Ergebnis auf die richtige Länge bringen
|
||||
String[] result = new String[pos];
|
||||
System.arraycopy(temp, 0, result, 0, pos);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Hauptmethode.
|
||||
*
|
||||
* @param args Kommandozeilen-Argumente.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
try {
|
||||
String[] words = listWords(
|
||||
"pr2/collections/list/kafka.txt");
|
||||
System.out.println(Arrays.toString(words));
|
||||
}
|
||||
catch (IOException e) {
|
||||
System.err.println("Probleme beim Dateizugriff: " + e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
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;
|
||||
|
||||
// TODO: Klasse ListenIterator implementieren
|
||||
|
||||
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 null;
|
||||
// TODO: neuen ListenIterator zurück geben
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
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 {
|
||||
|
||||
// TODO: Map deklarieren
|
||||
|
||||
// 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) {
|
||||
// TODO: Worthäufigkeiten in Map speichern
|
||||
}
|
||||
}
|
||||
|
||||
reader.close();
|
||||
|
||||
// TODO: Worthäufigkeiten aus der Map extrahieren und sortieren
|
||||
|
||||
// TODO: Ergebnis zurückgeben
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Hauptmethode.
|
||||
*
|
||||
* @param args Kommandozeilen-Argumente.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
try {
|
||||
List<WordFrequency> words = countWords(
|
||||
"pr2/collections/map/kafka.txt");
|
||||
|
||||
for (WordFrequency word : words) {
|
||||
System.out.println(word);
|
||||
}
|
||||
} catch (IOException e) {
|
||||
System.err.println("Probleme beim Dateizugriff: " + e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
package pr2.collections.map;
|
||||
|
||||
/**
|
||||
* Klasse für die Verwaltung der Worthäufigkeiten.
|
||||
*/
|
||||
public class WordFrequency {
|
||||
// TODO: Sortierbar machen [Comparable]
|
||||
|
||||
/**
|
||||
* 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;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* 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,14 @@
|
|||
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) {
|
||||
|
||||
// TODO: Liste umgekehrt sortieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
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() {
|
||||
// TODO: Reverser testen
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
package pr2.collections.reverser_generic;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
|
||||
public class Reverser {
|
||||
|
||||
public void reverse(List<String> liste) {
|
||||
|
||||
// TODO: Liste umgekehrt sortieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
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() {
|
||||
// TODO: Reverser testen
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,158 @@
|
|||
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 Wort
|
||||
* @throws IOException Fehler beim Dateizugriff.
|
||||
*/
|
||||
public static String[] listWords(String filename) throws IOException {
|
||||
String[] allWords = readFileAndSplitIntoWords(filename);
|
||||
String[] result = removeDuplicates(allWords);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listet alle Worte in der Datei auf.
|
||||
*
|
||||
* @param filename Dateiname
|
||||
* @return die Liste der vorhandenen Wort
|
||||
* @throws IOException Fehler beim Dateizugriff.
|
||||
*/
|
||||
private static String[] readFileAndSplitIntoWords(String filename)
|
||||
throws IOException {
|
||||
|
||||
// Datei zum Lesen öffnen
|
||||
BufferedReader reader = new BufferedReader(
|
||||
new FileReader(filename));
|
||||
|
||||
String line; // aktuelle Zeile
|
||||
String[] wordBuffer = new String[100]; // Puffer für die Worte
|
||||
int pos = 0; // Position im Word-Puffer
|
||||
|
||||
// Ü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
|
||||
for (String word : words) {
|
||||
|
||||
if (pos >= wordBuffer.length) {
|
||||
// Puffer ist voll, vergrößern
|
||||
String[] newBuffer =
|
||||
new String[wordBuffer.length * 2];
|
||||
System.arraycopy(wordBuffer, 0, newBuffer,
|
||||
0, wordBuffer.length);
|
||||
wordBuffer = newBuffer;
|
||||
}
|
||||
|
||||
wordBuffer[pos++] = word;
|
||||
}
|
||||
}
|
||||
|
||||
reader.close();
|
||||
|
||||
// Ergebnis-Array mit der richtigen Größe anlegen
|
||||
String[] result = new String[pos];
|
||||
System.arraycopy(wordBuffer, 0, result, 0, pos);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sortiert das übergebene Array alphabetisch und entfernt Duplikate.
|
||||
*
|
||||
* @param input Eingabe Array
|
||||
* @return sortiertes und bereinigtes Array
|
||||
*/
|
||||
private static String[] removeDuplicates(String[] input) {
|
||||
|
||||
// Eingabe Array clonen, da es verändert wird (Seiteneffekt)
|
||||
String[] strings = input.clone();
|
||||
|
||||
// Array sortieren
|
||||
Arrays.sort(strings);
|
||||
|
||||
// Über die Einträge laufen
|
||||
for (int i = 0; i < strings.length; i++) {
|
||||
String word = strings[i];
|
||||
|
||||
if (word == null) {
|
||||
// Bereits entfernter Eintrag
|
||||
continue;
|
||||
}
|
||||
|
||||
// Über die Einträge laufen
|
||||
for (int k = i + 1; k < strings.length; k++) {
|
||||
String otherWord = strings[k];
|
||||
|
||||
if (otherWord == null) {
|
||||
// Bereits entfernter Eintrag
|
||||
continue;
|
||||
}
|
||||
else if (otherWord.compareTo(word) > 0) {
|
||||
// Sind schon hinter der möglichen Position
|
||||
break;
|
||||
}
|
||||
else if (otherWord.equals(word)) {
|
||||
// Duplikat, ausnullen
|
||||
strings[k] = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Ausgenullte Einträge entfernen
|
||||
int pos = 0;
|
||||
String[] temp = new String[strings.length];
|
||||
|
||||
for (int i = 0; i < strings.length; i++) {
|
||||
if (strings[i] != null) {
|
||||
temp[pos++] = strings[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Ergebnis auf die richtige Länge bringen
|
||||
String[] result = new String[pos];
|
||||
System.arraycopy(temp, 0, result, 0, pos);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Hauptmethode.
|
||||
*
|
||||
* @param args Kommandozeilen-Argumente.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
try {
|
||||
String[] words = listWords("pr2/collections/set/kafka.txt");
|
||||
System.out.println(Arrays.toString(words));
|
||||
}
|
||||
catch (IOException e) {
|
||||
System.err.println("Probleme beim Dateizugriff: " + e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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) {
|
||||
// TODO: Sortierung der Argumente durchführen
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
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) {
|
||||
// TODO: Sortierung der Argumente durchführen
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
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) {
|
||||
// TODO: Methode implementieren
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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,12 @@
|
|||
package pr2.collections.woerterbuch;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
public class Woerterbuch {
|
||||
|
||||
|
||||
public static void main(String[] args) {
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue