Update of exercises
Thomas Smits
parent
8e2d5db684
commit
d4c8c8df35
|
|
@ -0,0 +1,38 @@
|
|||
# `BufferedReader` zum zeilenweisen Lesen einsetzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten Zeilenweise mit einem `BufferedReader` verwenden und dabei das Decorator Pattern einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.buffered_reader](../sources/src/main/java/pr2/io/buffered_reader/).
|
||||
|
||||
Lesen Sie die Datei [kafka.txt](assets/kafka.txt) zeilenweise ein und geben Sie die Zeilen mit einer fortlaufenden Zeilennummer wieder aus. Verwenden Sie hierzu einen `BufferedReader`.
|
||||
|
||||
Eine beispielhaft Ausgabe sieht wie folgt aus:
|
||||
|
||||
```console
|
||||
1: Verhaftung - Gespräch mit Frau Grubach - Dann Fräulein Bürstner
|
||||
2:
|
||||
3: Jemand mußte Josef K. verleumdet haben, denn ohne daß er etwas Böses
|
||||
4: getan hätte, wurde er eines Morgens verhaftet. Die Köchin der Frau
|
||||
5: Grubach, seiner Zimmervermieterin, die ihm jeden Tag gegen acht Uhr früh
|
||||
6: das Frühstück brachte, kam diesmal nicht. Das war noch niemals
|
||||
```
|
||||
|
||||
Lassen Sie das Programm laufen und überprüfen Sie, ob die Ausgabe korrekt ist. Die Beispieldatei hat 232 Zeilen.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
# DataOutputStream
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten mit einem `DataOutputStreams` manuell serialisieren.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.datainputoutput_1](../sources/src/main/java/pr2/io/datainputoutput_1/).
|
||||
|
||||
Schreiben Sie eine Klasse `DateWriter`, die ein Datum in der Form yyyy-MM-dd (z.B. 1997-08-29) von der Konsole annimmt und als `long`-Wert mithilfe eines `DataOutputStreams` in eine Datei schreibt.
|
||||
|
||||
Schreiben Sie eine Klasse `DateReader`, die den `long`-Wert aus der Datei ausliest und wieder in das ursprüngliche Format bringt und auf der Konsole ausgibt.
|
||||
|
||||
**Hinweis:** Zur Konvertierung eines Strings in ein Datum und umgekehrt, können Sie die Klasse `SimpleDateFormat` verwenden. Ein `Date`-Objekt lässt sich leicht über die Methode `getTime` in einen `long`-Wert umwandeln. Denken Sie an eine korrekte Behandlung von möglichen Fehlern.
|
||||
|
||||
```console
|
||||
> java DateWriter 1997-08-29
|
||||
> java DateReader
|
||||
Das Datum war: 1997-08-29
|
||||
```
|
||||
|
||||
**Zusatzfrage:** Welche besondere Bedeutung hat das hier als Beispiel verwendete Datum?
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# DataOutputStream durch Serialisierung ersetzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten mit einem `ObjectOutputStreams` serialisieren.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.datainputoutput_2](../sources/src/main/java/pr2/io/datainputoutput_2/).
|
||||
|
||||
Verändern Sie die beiden Klassen aus der vorhergehenden Aufgabe so, dass sie jetzt anstatt eines `DataOutputStreams` bzw. eines `DataInputStreams` Serialisierung verwenden.
|
||||
|
||||
Vergleichen Sie bitte die Dateien, die bei diesem und der anderen Lösung entstanden sind. Was fällt ihnen auf?
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
# Daten mit `DataOutputStream` und `DataInputStream` verarbeiten
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Ein eigenes Format für die Daten einer Klasse definieren und diese Dann in einer Datei speichern und aus dieser wieder laden.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.data_output](../sources/src/main/java/pr2/io/data_output/).
|
||||
|
||||
In dieser Aufgabe finden Sie bereits eine fertig implementierte Klasse `Board` vor, die ein Schachbrett repräsentiert. Allerdings wird dieses nicht für Schach benutzt, sondern für ein Spiel, bei dem man nur schwarze und weiße Steine auf das Brett stellen kann (z.B. Dame). Die Farbe der Steine wird durch die Enumeration `Color` dargestellt.
|
||||
|
||||
Was bei dem Schachbrett allerdings noch fehlt, ist eine Möglichkeit den Spielstand zu speichern und später wieder einzulesen.
|
||||
|
||||
Schauen Sie sich die Klassen `Board` und `Color` genau an und versuchen Sie diese zu verstehen. Sie können auch testweise ein Brett anlegen und mit Daten befüllen. (Wie dies geht, sehen Sie im JUnit-Test). Die `toString()`-Methode liefert eine anschauliche Darstellung des Spielfeldes.
|
||||
|
||||
Implementieren Sie nun die Methoden `writeToFile` und `loadFromFile` unter Zuhilfenahme von `DateOutputStream` und `DataInputStream`. Hierzu müssen Sie noch das Datenformat für die Speicherung festlegen. Dieses ist wie folgt definiert:
|
||||
|
||||
1. Als erstes der String "Schachbrett" im UTF8-Format, um das Datenformat zu kennzeichnen.
|
||||
2. Die Koordinaten der ersten Figur im Format x-Pos, y-Pos (beide als `byte`) und Farbe entsprechend `Color.ordinal()` (als `int`)
|
||||
3. Wiederholung von Schritt 2. bis alle Figuren gespeichert sind.
|
||||
4. Werte `0xff`, `0xff`, `-1`, um das Dateiende zu kennzeichnen
|
||||
|
||||
Lassen Sie den JUnit-Test laufen, um zu sehen, ob die Daten korrekt verarbeitet werden.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# Daten mit einem `InputStream` lesen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen `InputStream` benutzen, um Daten aus einer Datei zu lesen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.datei_lesen](../sources/src/main/java/pr2/io/datei_lesen/).
|
||||
|
||||
Lesen Sie die Daten aus der Datei `daten.dat` byteweise und geben Sie den Inhalt auf der Konsole aus. Für die Ausgabe verwenden Sie bitte die Hexadezimale Darstellung, also z.B. `0x0a` für den Wert 11.
|
||||
|
||||
Lassen Sie das Programm laufen und betrachten Sie die Ausgabe. Wenn Sie alles korrekt implementiert haben, sollten Sie den Text
|
||||
|
||||
0xca 0xff 0xfe 0xba 0xbe 0x0 0xde 0xad 0xbe 0xef
|
||||
|
||||
sehen.
|
||||
|
||||
Denken Sie auch an eine Fehlerbehandlung für eventuelle Ausnahmen im Zusammenhang mit der Datei.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# Daten mit einem `OutputStream` schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen `OutputStream` verwenden, um Daten zu schreiben.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.datei_schreiben](../sources/src/main/java/pr2/io/datei_schreiben/).
|
||||
|
||||
In dieser Aufgabe sollen Sie eine Reihe von Bytes in eine Datei schreiben. Ein JUnit-Test wird überprüfen, ob Sie dies richtig getan haben.
|
||||
|
||||
Öffnen Sie einen passenden `OutputStream`, um in die Datei `output/daten.dat` zu schreiben (verwenden Sie die Konstante `FILE` für den Dateinamen). Schreiben Sie nun die Byte-Folge
|
||||
|
||||
```console
|
||||
0xca 0xff 0xfe 0xba 0xbe 0x0 0xde 0xad 0xbe 0xef
|
||||
```
|
||||
|
||||
hinein und schließen Sie die Datei wieder.
|
||||
|
||||
Führen Sie den JUnit-Test aus, der überprüft, ob alle Daten korrekt in die Datei geschrieben wurden.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
# Filesystem-Abstraktion mit `File`
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Die Klasse `Path` einsetzen, um plattformunabhängig Operationen auf dem Dateisystem durchzuführen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.file](../sources/src/main/java/pr2/io/file/).
|
||||
|
||||
Benutzen Sie die Klasse `Path`, um die Festplatte Ihres Computers, ausgehend von dem als `root` bezeichneten Verzeichnis `../..` zu durchsuchen und die Größe der Verzeichnisse zu berechnen.
|
||||
|
||||
Sie können die Größe eines Verzeichnisses nur indirekt bestimme, indem Sie die Größe aller Dateien in dem Verzeichnis addieren. Das Verzeichnis direkt kann man _nicht_ mit `size()` nach seiner Größe fragen, wohl aber normale Dateien. Deswegen müssen Sie in Ihrem Programm immer sauber unterscheiden, ob ein Verzeichnis vorliegt (das sie rekursiv durchlaufen müssen) oder eine normale Datei (deren Größe Sie abfragen).
|
||||
|
||||
Geben Sie die Verzeichnisse mit Ihrer Größe aus. Am Ende des Programms geben Sie noch die Gesamtgröße aller Unterverzeichnisse aus. Eine beispielhafte sähe wie folgt aus:
|
||||
|
||||
```console
|
||||
Untersuche: /home/thomas/eclipse-workspace
|
||||
|
||||
465 Byte - /home/thomas/eclipse-workspace/.recommenders/snipmatch/repositories
|
||||
1,4 kByte - /home/thomas/eclipse-workspace/.recommenders/snipmatch
|
||||
4,6 MByte - /home/thomas/eclipse-workspace/.recommenders
|
||||
57,5 MByte - /home/thomas/eclipse-workspace
|
||||
103 Byte - /home/thomas/lib/.settings
|
||||
5,8 MByte - /home/thomas/lib
|
||||
|
||||
Gesamtgröße: 80,4 MByte
|
||||
```
|
||||
|
||||
Lassen Sie Ihr Programm laufen und überprüfen Sie, ob die Ausgaben plausibel sind. Vergleichen Sie das Ergebnis mit den Angaben des Windows-Explorers, Mac-Finders oder Linux-Dateimanagers.
|
||||
|
||||
Unter Linux und MacOS müssen Sie darauf achten, dass Sie symbolischen Links in Ihrem Programm nicht folgen, sonst zählen Sie möglicherweise zu viel.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
# Fileattribute lesen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Methoden der Klassen `Path` und `Files` nutzen und verstehen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.filetest](../sources/src/main/java/pr2/io/filetest/).
|
||||
|
||||
Schreiben Sie eine Klasse `FileInfo`, der man auf der Konsole einen Datei- oder Verzeichnisnamen übergeben kann. Sie soll dann einige grundlegende Informationen über die Datei ausgeben (siehe Beispiel).
|
||||
|
||||
```console
|
||||
> java FileTest /Users/thomas/Documents/../Documents/
|
||||
/Users/thomas/Documents existiert
|
||||
/Users/thomas/Documents ist 408 Bytes groß
|
||||
/Users/thomas/Documents ist ein Verzeichnis
|
||||
/Users/thomas/Documents darf gelesen werden
|
||||
/Users/thomas/Documents darf geschrieben werden
|
||||
|
||||
> java FileTest /Users/thomas/Documents/../Documents/Uebungsklausur.pages
|
||||
/Users/thomas/Documents/Uebungsklausur.pages existiert
|
||||
/Users/thomas/Documents/Uebungsklausur.pages ist 258920 Bytes groß
|
||||
/Users/thomas/Documents/Uebungsklausur.pages ist ein normale Datei
|
||||
/Users/thomas/Documents/Uebungsklausur.pages darf gelesen werden
|
||||
/Users/thomas/Documents/Uebungsklausur.pages darf geschrieben werden
|
||||
```
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# `FilterReader`
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen eigenen Filter in Form eines `FilterReaders` programmieren und hiermit in den Datenstrom eingreifen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.filter](../sources/src/main/java/pr2/io/filter/).
|
||||
|
||||
Vervollständigen Sie die Klasse `UCaseReader` so, dass Sie als Filter (`FilterReader`) verwendet werden kann. Die Aufgabe dieses Filters besteht darin, alle gelesenen Zeichen in Großbuchstaben umzuwandeln.
|
||||
|
||||
Testen Sie, ob Ihre Implementierung korrekt ist, indem Sie die JUnit-Tests ausführen.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# Konsolen Input/Output
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten von der Konsole lesen und über eine Ausgabeumlenkung in eine Datei umlenken. `PrintStream` und `InputStreamReader` einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.konsole](../sources/src/main/java/pr2/io/konsole/).
|
||||
|
||||
Lesen Sie zeilenweise mithilfe eines `BufferedReaders` von der Konsole Zeichen ein. Geben Sie diese wieder auf `System.out` aus und zeigen Sie die aktuelle Zeilennummer auf `System.err` an.
|
||||
|
||||
Testen Sie das Programm.
|
||||
|
||||
Lenken Sie nun die Ausgabe von `System.out` in die Datei `output/console.log` um (siehe Konstante `LOGFILE`). Lassen Sie das Programm erneut laufen und betrachten Sie danach die Datei mit den umgeleiteten Daten.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
# Zeilen einer Textdatei zählen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Dateien zeilenweise lesen und verarbeiten.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.linecounter](../sources/src/main/java/pr2/io/linecounter/).
|
||||
|
||||
Schreiben Sie eine Klasse `LineCounter`, die den Namen einer Textdatei von der Kommandozeile entgegennimmt und dann die Anzahl der Zeilen in der Datei ausgibt.
|
||||
|
||||
```console
|
||||
> java LineCounter ../src/LineCounter.java
|
||||
Datei: ../src/LineCounter.java hat 30 Zeilen
|
||||
```
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# `RandomAccessFile`
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
`RandomAccessFile` sowohl zum Lesen, als auch zum Schreiben von Daten einsetzen. Verstehen, dass man sich wahlfrei durch die Datei bewegen kann.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.random_access](../sources/src/main/java/pr2/io/random_access/).
|
||||
|
||||
Bei dieser Aufgabe werden Sie ein Verfahren anwenden, das bei sehr großen Datenmengen zum Einsatz kommt: das Sortieren der Daten direkt auf der Festplatte, ohne sie vollständig in den Hauptspeicher zu laden.
|
||||
|
||||
Implementieren Sie einen [Bubblesort](https://de.wikipedia.org/wiki/Bubblesort) mithilfe von `RandomAccessFile` direkt auf einer Datei. Bubblesort ist ein ausgesprochen ineffizienter Algorithmus (O(n*n)), er ist aber sehr einfach zu implementieren. Da die zu sortierende Datei klein ist, können wir hier mit den Nachteilen von Bubblesort leben.
|
||||
|
||||
Implementieren Sie die bereits vorhandene Methode `sortFile` der Klasse `FileSort`. Öffnen Sie zuerst die Datei mithilfe von `RandomAccessFile` im Modus `"rw"`. Wandern Sie nun - entsprechend dem Bubblesort-Algorithmus - über die Daten und sortieren Sie die Bytes der Datei. Halten Sie nie mehr als zwei `byte` und die Position als `long` im Speicher. Weitere Variablen können auch noch nötig sein, um den Algorithmus zu implementieren.
|
||||
|
||||
Testen Sie Ihre Implementierung mit den JUnit-Tests.
|
||||
|
||||
|
||||
## 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 @@
|
|||
# `Reader` verwenden
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Textdaten mithilfe von `Reader` verarbeiten.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.reader_writer](../sources/src/main/java/pr2/io/reader_writer/).
|
||||
|
||||
Lesen Sie die Datei [kafka.txt](assets/kafka.txt) mit einem passenden `Reader` ein und geben Sie sie auf der Konsole aus. Verwenden Sie nicht die `read()`-Methode, die einzelne Zeichen verarbeitet, sondern arbeiten Sie mit einem `char[]`-Buffer.
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# Rot13-Verschlüsselung
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Funktionsweise und Einsatz von Filtern.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.rot13](../sources/src/main/java/pr2/io/rot13/).
|
||||
|
||||
Schreiben Sie eine Klasse `Rot13Reader`, die als Filter-Reader implementiert ist und jedes eingelesene Zeichen durch ein Zeichen ersetzt, dessen numerischer Wert um 13 höher ist (d.h. um 13 Schritte im Alphabet verschoben ist).
|
||||
|
||||
Schreiben Sie eine Klasse `Rot13`, die einen Dateinamen von der Kommandozeile nimmt und diese Text-Datei mithilfe von `Rot13Reader` liest und auf der Konsole ausgibt.
|
||||
|
||||
```console
|
||||
> cat /tmp/test
|
||||
DIES IST EIN TEXT, DER GLEICH ROT13 VERSCHLUESSELT WIRD.
|
||||
|
||||
> java Rot13 /tmp/test
|
||||
QVR`-V`a-RV[-aRea9-QR_-TYRVPU-_\a>@-cR_`PUYbR``RYa-dV_Q;
|
||||
```
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
# Datei zerhacken
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten byteweise aus einem Stream lesen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.scrambler](../sources/src/main/java/pr2/io/scrambler/).
|
||||
|
||||
Schreiben Sie eine Klasse `Scrambler`, die einen Dateinamen von der Kommandozeile entgegennimmt, die Datei einliest und dann wieder auf der Konsole ausgibt. Allerdings soll bei der Ausgabe nur jedes zweite Byte berücksichtigt werden.
|
||||
|
||||
```console
|
||||
> java Scrambler ../src/Scrambler.java
|
||||
motjv.oFlIpttem
|
||||
motjv.oFlNtonEcpin
|
||||
motjv.oIEcpin
|
||||
pbi ls cabe
|
||||
pbi ttcvi anSrn[ rs hosIEcpin{ i ag.egh! ){ Sse.r.rnl(
|
||||
Bteen ae nee"; Sse.xt1; }
|
||||
ienuSra i;
|
||||
r
|
||||
i e ienuSra(rs0)
|
||||
```
|
||||
|
||||
|
||||
## Abgabe (optional)
|
||||
|
||||
__Sie müssen keine Lösung für diese Aufgabe einreichen.__
|
||||
|
||||
Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
|
||||
|
||||
1. Öffnen Sie eine Kommandozeile (Terminal).
|
||||
2. Gehen Sie in Ihr Working Directory.
|
||||
3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
|
||||
4. Bauen Sie das Projekt mit dem Kommando `mvn`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# Serialisierung
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Serialisierung einsetzen können, um Objekte zu persistieren und wieder zu laden.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.serialisierung](../sources/src/main/java/pr2/io/serialisierung/).
|
||||
|
||||
In dieser Aufgabe finden Sie bereits eine fertig implementierte Klasse `Board` vor, die ein Schachbrett repräsentiert. Allerdings wird dieses nicht für Schach benutzt, sondern für ein Spiel, bei dem man nur schwarze und weiße Steine auf das Brett stellen kann (z.B. Dame). Die Farbe der Steine wird durch die Enumeration `Color` dargestellt.
|
||||
|
||||
Was bei dem Schachbrett allerdings noch fehlt, ist eine Möglichkeit den Spielstand zu speichern und später wieder einzulesen.
|
||||
|
||||
Schauen Sie sich die Klassen `Board` und `Color` genau an und versuchen Sie diese zu verstehen. Sie können auch testweise ein Brett anlegen und mit Daten befüllen. (Wie dies geht, sehen Sie im JUnit-Test). Die `toString()`-Methode liefert eine anschauliche Darstellung des Spielfeldes.
|
||||
|
||||
Implementieren Sie nun die Methoden `writeToFile` und `loadFromFile` unter Zuhilfenahme von Serialisierung. D.h. anders als in der Aufgabe zu `DataOutputStream`, sollen Sie hier kein eigenes Datenformat implementieren. Verwenden Sie stattdessen einen `ObjectOutputStream` bzw. `ObjectInputStream`.
|
||||
|
||||
Lassen Sie den JUnit-Test laufen, um zu sehen, ob die Daten korrekt verarbeitet werden.
|
||||
|
||||
|
||||
## 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`.
|
||||
16
readme.md
16
readme.md
|
|
@ -55,3 +55,19 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
|
|||
| 45. | 27.04.2023 | [Eigene Exception schreiben](Assignment_045/readme.md) |
|
||||
| 46. | 27.04.2023 | [Handle-or-Declare-Regel anwenden](Assignment_046/readme.md) |
|
||||
| 47. | 27.04.2023 | [Ausnahmen mit `try` und `catch` behandeln.](Assignment_047/readme.md) |
|
||||
| 48. | 04.05.2023 | [`BufferedReader` zum zeilenweisen Lesen einsetzen](Assignment_048/readme.md) |
|
||||
| 49. | 04.05.2023 | [DataOutputStream](Assignment_049/readme.md) |
|
||||
| 50. | 04.05.2023 | [DataOutputStream durch Serialisierung ersetzen](Assignment_050/readme.md) |
|
||||
| 51. | 04.05.2023 | [Daten mit `DataOutputStream` und `DataInputStream` verarbeiten](Assignment_051/readme.md) |
|
||||
| 52. | 04.05.2023 | [Daten mit einem `InputStream` lesen](Assignment_052/readme.md) |
|
||||
| 53. | 04.05.2023 | [Daten mit einem `OutputStream` schreiben](Assignment_053/readme.md) |
|
||||
| 54. | 04.05.2023 | [Filesystem-Abstraktion mit `File`](Assignment_054/readme.md) |
|
||||
| 55. | 04.05.2023 | [Fileattribute lesen](Assignment_055/readme.md) |
|
||||
| 56. | 04.05.2023 | [`FilterReader`](Assignment_056/readme.md) |
|
||||
| 57. | 04.05.2023 | [Konsolen Input/Output](Assignment_057/readme.md) |
|
||||
| 58. | 04.05.2023 | [Zeilen einer Textdatei zählen](Assignment_058/readme.md) |
|
||||
| 59. | 04.05.2023 | [`RandomAccessFile`](Assignment_059/readme.md) |
|
||||
| 60. | 04.05.2023 | [`Reader` verwenden](Assignment_060/readme.md) |
|
||||
| 61. | 04.05.2023 | [Rot13-Verschlüsselung](Assignment_061/readme.md) |
|
||||
| 62. | 04.05.2023 | [Datei zerhacken](Assignment_062/readme.md) |
|
||||
| 63. | 04.05.2023 | [Serialisierung](Assignment_063/readme.md) |
|
||||
|
|
|
|||
|
|
@ -0,0 +1,25 @@
|
|||
package pr2.io.buffered_reader;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.FileReader;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Liest eine Textdatei und gibt den Inhalt auf der Konsole aus.
|
||||
*/
|
||||
public class LineNumberPrinter {
|
||||
|
||||
/**
|
||||
* Hauptmethode.
|
||||
*
|
||||
* @param args Kommandozeilen-Argumente.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
String filename = args.length == 1
|
||||
? args[0]
|
||||
: "pr2/io/reader_writer/kafka.txt";
|
||||
|
||||
// TODO: Datei lesen und mit Zeilennummern wieder ausgeben
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
package pr2.io.data_output;
|
||||
|
||||
import java.io.DataInputStream;
|
||||
import java.io.DataOutputStream;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Ein Dame-Brett.
|
||||
*/
|
||||
public class Board {
|
||||
|
||||
/**
|
||||
* Belegung des Brettes.
|
||||
*/
|
||||
private final Color[][] brett = new Color[8][8];
|
||||
|
||||
/**
|
||||
* Liest den Inhalt aus einer Datei.
|
||||
*
|
||||
* @param file Dateipfad.
|
||||
* @return das gelesene Spielfeld
|
||||
* @throws IOException IO-Probleme
|
||||
*/
|
||||
public static Board loadFromFile(String file) throws IOException {
|
||||
|
||||
Board result = new Board();
|
||||
|
||||
|
||||
// TODO: Daten aus Datei lesen
|
||||
// TODO: Zuerst überprüfen, ob Datei mit "Schachbrett" anfängt, wenn nein, Ausnahme werfen
|
||||
// TODO: Positionen und Farbe der Figuren einlesen
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Schreibt den Inhalt des Spielfeldes in eine Datei.
|
||||
*
|
||||
* @param file Dateiname.
|
||||
* @throws IOException IO-Probleme
|
||||
*/
|
||||
public void writeToFile(String file) throws IOException {
|
||||
|
||||
// TODO: Daten mit DataOutputStream persistieren
|
||||
// TODO: String "Schachbrett" speichern, um das Datenformat zu definieren
|
||||
// TODO: x- und y-Koordinate des Steins und seine Farbe (als Integer) speichern
|
||||
// TODO: Dateiende mit 0xff 0xff -1 kennzeichnen
|
||||
}
|
||||
|
||||
/**
|
||||
* Setzt einen Stein an die gegebene Koordinate.
|
||||
*
|
||||
* @param koordinate Koordinate in "a1"-Notation.
|
||||
* @param farbe Fabe des Spielsteins.
|
||||
*/
|
||||
public void set(String koordinate, Color farbe) {
|
||||
Tupel t = parseCoordinates(koordinate);
|
||||
brett[t.x][t.y] = farbe;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wandelt textuelle Koordinaten in x- und y-Wert um.
|
||||
*
|
||||
* @param koordinate Koordinate als String.
|
||||
* @return Koordinate als Integer-Tupel.
|
||||
*/
|
||||
private Tupel parseCoordinates(String koordinate) {
|
||||
char buchstabe = koordinate.toLowerCase().charAt(0);
|
||||
char zahl = koordinate.charAt(1);
|
||||
|
||||
Tupel t = new Tupel();
|
||||
|
||||
t.y = buchstabe - 'a';
|
||||
t.x = zahl - '1';
|
||||
|
||||
if (t.x < 0 || t.x > 7) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
|
||||
if (t.y < 0 || t.y > 7) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
/**
|
||||
* @see java.lang.Object#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
|
||||
StringBuilder result = new StringBuilder();
|
||||
|
||||
char y = '1';
|
||||
|
||||
result.append(" ");
|
||||
for (char c : "abcdefgh".toCharArray()) {
|
||||
result.append(' ').append(c);
|
||||
}
|
||||
|
||||
result.append("\n");
|
||||
|
||||
for (Color[] figurs : brett) {
|
||||
|
||||
result.append(y++);
|
||||
|
||||
for (Color figur : figurs) {
|
||||
if (figur != null) {
|
||||
result.append(' ').append(figur);
|
||||
}
|
||||
else {
|
||||
result.append(" ");
|
||||
}
|
||||
}
|
||||
|
||||
result.append("\n");
|
||||
}
|
||||
|
||||
return result.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tupel von zwei int-Werten.
|
||||
*/
|
||||
private static class Tupel {
|
||||
int x;
|
||||
|
||||
int y;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
package pr2.io.data_output;
|
||||
|
||||
/**
|
||||
* Farben der Spielsteine.
|
||||
*/
|
||||
public enum Color {
|
||||
|
||||
/**
|
||||
* Schwarzer Stein.
|
||||
*/
|
||||
BLACK,
|
||||
|
||||
/**
|
||||
* Weißer Stein.
|
||||
*/
|
||||
WHITE;
|
||||
|
||||
/**
|
||||
* @see java.lang.Enum#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
if (this == Color.BLACK) {
|
||||
return "B";
|
||||
}
|
||||
else {
|
||||
return "W";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
package pr2.io.data_output.test;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import pr2.io.data_output.Board;
|
||||
import pr2.io.data_output.Color;
|
||||
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
|
||||
/**
|
||||
* Test.
|
||||
*/
|
||||
public class BoardTest {
|
||||
|
||||
private static final byte[] RESULT = new byte[] {
|
||||
0x00, 0x0B, 0x53, 0x63, 0x68, 0x61, 0x63, 0x68, 0x62, 0x72, 0x65,
|
||||
0x74, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
|
||||
0x00, 0x00, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x01, 0x06,
|
||||
0x00, 0x00, 0x00, 0x01, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00, 0x02,
|
||||
0x04, 0x00, 0x00, 0x00, 0x01, 0x04, 0x05, 0x00, 0x00, 0x00, 0x01,
|
||||
0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x05, 0x00, 0x00, 0x00,
|
||||
0x00, (byte) 0xff, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
|
||||
(byte) 0xFF, (byte) 0xFF
|
||||
};
|
||||
|
||||
/**
|
||||
* Test für die Implementierung des Spielbrettes.
|
||||
*
|
||||
* @throws IOException Datei-Probleme.
|
||||
*/
|
||||
@Test
|
||||
void testDame() throws IOException {
|
||||
Board s = new Board();
|
||||
s.set("a1", Color.BLACK);
|
||||
s.set("b1", Color.WHITE);
|
||||
s.set("h1", Color.BLACK);
|
||||
s.set("h2", Color.BLACK);
|
||||
s.set("a8", Color.BLACK);
|
||||
s.set("f8", Color.BLACK);
|
||||
s.set("f5", Color.WHITE);
|
||||
s.set("e3", Color.WHITE);
|
||||
s.set("g2", Color.WHITE);
|
||||
|
||||
String stringRepresentation = s.toString();
|
||||
|
||||
s.writeToFile("/tmp/daten.dat");
|
||||
|
||||
s = Board.loadFromFile("/tmp/daten.dat");
|
||||
|
||||
assertEquals(stringRepresentation, s.toString());
|
||||
|
||||
FileOutputStream fos = new FileOutputStream("/tmp/testdata.dat");
|
||||
fos.write(RESULT);
|
||||
fos.close();
|
||||
|
||||
s = Board.loadFromFile("/tmp/testdata.dat");
|
||||
|
||||
assertEquals(stringRepresentation, s.toString());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
package pr2.io.datainputoutput_1;
|
||||
|
||||
import java.io.DataInputStream;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
import java.text.DateFormat;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Date;
|
||||
|
||||
public class DateReader {
|
||||
public static void main(String[] args) {
|
||||
|
||||
// TODO: Implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
package pr2.io.datainputoutput_1;
|
||||
|
||||
import java.io.DataOutputStream;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.text.DateFormat;
|
||||
import java.text.ParseException;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Date;
|
||||
|
||||
public class DateWriter {
|
||||
|
||||
/**
|
||||
* Dateiname mit den Testdaten.
|
||||
*/
|
||||
public static final String DATEINAME = "/tmp/test.data";
|
||||
|
||||
/**
|
||||
* Datumsformat.
|
||||
*/
|
||||
public static final String FORMAT = "yyyy-MM-dd";
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
// TODO: Implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
package pr2.io.datainputoutput_2;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.text.DateFormat;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Date;
|
||||
|
||||
public class DateReader {
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
// TODO: Implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
package pr2.io.datainputoutput_2;
|
||||
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.text.DateFormat;
|
||||
import java.text.ParseException;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Date;
|
||||
|
||||
public class DateWriter {
|
||||
|
||||
/**
|
||||
* Dateiname mit den Testdaten.
|
||||
*/
|
||||
public static final String DATEINAME = "/tmp/test.ser";
|
||||
|
||||
/**
|
||||
* Datumsformat.
|
||||
*/
|
||||
public static final String FORMAT = "yyyy-MM-dd";
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
// TODO: Implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
package pr2.io.datei_lesen;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
/**
|
||||
* Daten aus einer Datei lesen.
|
||||
*/
|
||||
public class ReadData {
|
||||
|
||||
/**
|
||||
* Datei.
|
||||
*/
|
||||
private static final String FILE = "pr2/io/datei_lesen/daten.dat";
|
||||
|
||||
/**
|
||||
* Hauptmethode.
|
||||
*
|
||||
* @param args Kommandozeilenargumente.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
// TODO: Datei `FILE` öffnen
|
||||
// TODO: Bytes aus der Datei lesen
|
||||
// TODO: Bytes in Strings umwandeln (siehe Klasse `Integer`)
|
||||
// TODO: Bytes ausgeben
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
package pr2.io.datei_schreiben;
|
||||
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
|
||||
/**
|
||||
* Daten aus einer Datei lesen.
|
||||
*/
|
||||
public class WriteData {
|
||||
|
||||
/**
|
||||
* Datei.
|
||||
*/
|
||||
public static final String FILE = "pr2/io/datei_schreiben/daten.dat";
|
||||
|
||||
/**
|
||||
* Hauptmethode.
|
||||
*
|
||||
* @param args Kommandozeilenargumente.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
package pr2.io.datei_schreiben.test;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import pr2.io.datei_schreiben.WriteData;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||
import static pr2.io.datei_schreiben.WriteData.FILE;
|
||||
|
||||
/**
|
||||
* Test für die geschriebenen Daten.
|
||||
*/
|
||||
public class DataTest {
|
||||
|
||||
/**
|
||||
* Geschriebene Daten testen.
|
||||
*
|
||||
* @throws IOException Datei-Probleme.
|
||||
*/
|
||||
@Test
|
||||
void testData() throws IOException {
|
||||
|
||||
WriteData.main(new String[0]);
|
||||
|
||||
InputStream is = new FileInputStream(FILE);
|
||||
|
||||
byte[] buffer = new byte[10];
|
||||
is.read(buffer);
|
||||
assertArrayEquals(
|
||||
new byte[] {(byte) 0xca, (byte) 0xff, (byte) 0xfe, (byte) 0xba,
|
||||
(byte) 0xbe, (byte) 0x00, (byte) 0xde, (byte) 0xad,
|
||||
(byte) 0xbe, (byte) 0xef}, buffer);
|
||||
|
||||
is.close();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
package pr2.io.file;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.List;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
/**
|
||||
* Klasse, die das Dateisystem durchläuft und Informationen ausgibt.
|
||||
*/
|
||||
public class FilesystemWalker {
|
||||
|
||||
/**
|
||||
* Haupt-Methode.
|
||||
*
|
||||
* @param args Kommandozeilen-Argumente.
|
||||
* @throws IOException IO-Probleme
|
||||
*/
|
||||
public static void main(String[] args) throws IOException {
|
||||
|
||||
String path = args.length > 0 ? args[0] : ".";
|
||||
|
||||
Path root = Path.of(path).normalize().toAbsolutePath();
|
||||
|
||||
System.out.println("Untersuche: " + root);
|
||||
System.out.println();
|
||||
|
||||
long total = walk(root);
|
||||
|
||||
System.out.println();
|
||||
System.out.println("Gesamtgröße: " + niceSize(total));
|
||||
}
|
||||
|
||||
/**
|
||||
* Rekursive Methode, um den Baum zu durchlaufen.
|
||||
*
|
||||
* @param startDir Verzeichnis, bei dem gestartet werden
|
||||
* soll.
|
||||
* @return die Größe des Verzeichnisses.
|
||||
*/
|
||||
private static long walk(Path startDir) {
|
||||
|
||||
// TODO: Methode implementieren
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wandelt die Größe in eine schönere Darstellung um.
|
||||
*
|
||||
* @param size Die Größe.
|
||||
* @return Schönere Darstellung.
|
||||
*/
|
||||
private static String niceSize(long size) {
|
||||
|
||||
if (size > 1000_000L) {
|
||||
return String.format("%.1f MByte", size / 1024.0 / 1024.0);
|
||||
}
|
||||
else if (size > 1000L) {
|
||||
return String.format("%.1f kByte", size / 1024.0);
|
||||
}
|
||||
else {
|
||||
return String.format("%d Byte", size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
package pr2.io.filetest;
|
||||
|
||||
import java.nio.file.Files;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Path;
|
||||
|
||||
public class FileInfo {
|
||||
|
||||
public static void main(String[] args) throws IOException {
|
||||
|
||||
// TODO: Implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
package pr2.io.filter;
|
||||
|
||||
import java.io.FilterReader;
|
||||
import java.io.IOException;
|
||||
import java.io.Reader;
|
||||
|
||||
/**
|
||||
* Filter-Reader, der den Inhalt in Großbuchstaben umwandelt.
|
||||
*/
|
||||
public class UCaseReader {
|
||||
|
||||
// TODO: FilterReader gemäß Aufgabenbeschreibung anlegen
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
package pr2.io.filter.test;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import pr2.io.filter.UCaseReader;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.IOException;
|
||||
import java.io.StringReader;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
/**
|
||||
* Test für die Rot13 "Verschlüsselung".
|
||||
*/
|
||||
public class UCaseReaderTest {
|
||||
|
||||
/**
|
||||
* Testmethode.
|
||||
*
|
||||
* @throws IOException IO-Probleme
|
||||
*/
|
||||
@Test
|
||||
void testReader() throws IOException {
|
||||
|
||||
// TODO: Einkommentieren
|
||||
// BufferedReader br = new BufferedReader(
|
||||
// new UCaseReader(new StringReader(
|
||||
// "Dies ist" + " ein Test für den UCASE-Reader.")));
|
||||
//
|
||||
// String line = br.readLine();
|
||||
// assertEquals("DIES IST EIN TEST FÜR DEN UCASE-READER.", line);
|
||||
//
|
||||
// br.close();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
package pr2.io.konsole;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStreamReader;
|
||||
import java.io.PrintStream;
|
||||
|
||||
/**
|
||||
* Liest einen Text von der Console und
|
||||
* schreibt ihn dann in eine Datei. Allerdings
|
||||
* erfolgt das Schreiben über eine Ausgabeumleitung
|
||||
* und nicht über Dateioperationen.
|
||||
*/
|
||||
public class ConsoleToFile {
|
||||
|
||||
/**
|
||||
* Logfile für Ausgaben.
|
||||
*/
|
||||
private static final String LOGFILE = "console.log";
|
||||
|
||||
/**
|
||||
* Hauptmethode.
|
||||
*
|
||||
* @param args Kommandozeile-Argumente.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
// TODO: Von Konsole zeilenweise lesen
|
||||
// TODO: Aktuelle Anzahl der Zeilen auf System.err ausgeben
|
||||
// TODO: System.out in die Datei `LOGFILE` umleiten
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
package pr2.io.linecounter;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.FileReader;
|
||||
import java.io.IOException;
|
||||
|
||||
public class LineCounter {
|
||||
|
||||
public static void main(String[] args) throws IOException {
|
||||
|
||||
int lines = 0;
|
||||
|
||||
// TODO: Implementieren
|
||||
|
||||
System.out.printf("Datei: %s hat %d Zeilen%n", args[0], lines);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
package pr2.io.random_access;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.RandomAccessFile;
|
||||
|
||||
/**
|
||||
* Sortierung von Dateien (in place).
|
||||
*/
|
||||
public class FileSort {
|
||||
|
||||
/**
|
||||
* Sortiert die Datei von Byte-Werten per Bubble-Sort.
|
||||
*
|
||||
* @param filename Dateiname
|
||||
* @throws IOException IO-Probleme
|
||||
*/
|
||||
public static void sortFile(String filename) throws IOException {
|
||||
|
||||
// TODO: Bubblesort implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
package pr2.io.random_access.test;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import pr2.io.random_access.FileSort;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* Testet die Sortierung per Random-Access-File.
|
||||
*/
|
||||
public class FileSortTest {
|
||||
|
||||
/**
|
||||
* Kopiert die Datei f1 als Datei f2.
|
||||
*
|
||||
* @param f1 Quell-Datei
|
||||
* @param f2 Ziel-Datei
|
||||
* @throws IOException IO-Probleme
|
||||
*/
|
||||
private static void copyFile(String f1, String f2) throws IOException {
|
||||
|
||||
FileInputStream fis = new FileInputStream(f1);
|
||||
FileOutputStream fos = new FileOutputStream(f2);
|
||||
|
||||
int b;
|
||||
|
||||
while ((b = fis.read()) != -1) {
|
||||
fos.write(b);
|
||||
}
|
||||
|
||||
fis.close();
|
||||
fos.close();
|
||||
}
|
||||
|
||||
/**
|
||||
* Testet die File-Sortierung.
|
||||
*
|
||||
* @throws IOException IO-Problem
|
||||
*/
|
||||
@Test
|
||||
void testBubbleSort() throws IOException {
|
||||
copyFile("assets/data.dat", "output/data.dat");
|
||||
FileSort.sortFile("output/data.dat");
|
||||
|
||||
InputStream is = new FileInputStream("output/data.dat");
|
||||
|
||||
int data;
|
||||
byte lastByte = 0;
|
||||
|
||||
while ((data = is.read()) >= 0) {
|
||||
byte b = (byte) data;
|
||||
assertTrue(b >= lastByte);
|
||||
lastByte = b;
|
||||
}
|
||||
|
||||
is.close();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
package pr2.io.reader_writer;
|
||||
|
||||
import java.io.FileReader;
|
||||
import java.io.IOException;
|
||||
import java.io.Reader;
|
||||
|
||||
/**
|
||||
* Liest eine Textdatei und gibt den Inhalt auf der Konsole aus.
|
||||
*/
|
||||
public class ReadAndPrintFile {
|
||||
|
||||
/**
|
||||
* Hauptmethode.
|
||||
*
|
||||
* @param args Kommandozeilen-Argumente.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
|
||||
String filename = args.length == 1
|
||||
? args[0]
|
||||
: "pr2/io/reader_writer/kafka.txt";
|
||||
|
||||
// TODO: Datei lesen und auf der Konsole ausgeben
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
package pr2.io.rot13;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.FileReader;
|
||||
import java.io.IOException;
|
||||
|
||||
public class Rot13 {
|
||||
|
||||
public static void main(String[] args) throws IOException {
|
||||
if (args.length != 1) {
|
||||
System.err.println("Bitte eine Datei angeben");
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
// TODO: Implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
package pr2.io.rot13;
|
||||
|
||||
import java.io.FilterReader;
|
||||
import java.io.IOException;
|
||||
import java.io.Reader;
|
||||
|
||||
public class Rot13Reader {
|
||||
|
||||
// TODO: Implementieren
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
package pr2.io.scrambler;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
|
||||
public class Scrambler {
|
||||
|
||||
public static void main(String[] args) throws IOException {
|
||||
if (args.length != 1) {
|
||||
System.err.println("Bitte eine Datei angeben");
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
package pr2.io.serialisierung;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.io.Serializable;
|
||||
|
||||
/**
|
||||
* Ein Dame-Brett.
|
||||
*/
|
||||
public class Board implements Serializable {
|
||||
|
||||
/**
|
||||
* Belegung des Brettes.
|
||||
*/
|
||||
private final Color[][] brett = new Color[8][8];
|
||||
|
||||
/**
|
||||
* Liest den Inhalt aus einer Datei.
|
||||
*
|
||||
* @param file Dateipfad.
|
||||
* @return das gelesene Spielfeld
|
||||
* @throws IOException IO-Probleme
|
||||
*/
|
||||
public static Board loadFromFile(String file) throws IOException {
|
||||
|
||||
// TODO: Aus einer Datei lesen
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Schreibt den Inhalt des Spielfeldes in eine Datei.
|
||||
*
|
||||
* @param file Dateiname.
|
||||
* @throws IOException IO-Probleme
|
||||
*/
|
||||
public void writeToFile(String file) throws IOException {
|
||||
}
|
||||
|
||||
/**
|
||||
* Setzt einen Stein an die gegebene Koordinate.
|
||||
*
|
||||
* @param koordinate Koordinate in "a1"-Notation.
|
||||
* @param farbe Fabe des Spielsteins.
|
||||
*/
|
||||
public void set(String koordinate, Color farbe) {
|
||||
Tupel t = parseCoordinates(koordinate);
|
||||
brett[t.x][t.y] = farbe;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wandelt textuelle Koordinaten in x- und y-Wert um.
|
||||
*
|
||||
* @param koordinate Koordinate als String.
|
||||
* @return Koordinate als Integer-Tupel.
|
||||
*/
|
||||
private Tupel parseCoordinates(String koordinate) {
|
||||
char buchstabe = koordinate.toLowerCase().charAt(0);
|
||||
char zahl = koordinate.charAt(1);
|
||||
|
||||
Tupel t = new Tupel();
|
||||
|
||||
t.y = buchstabe - 'a';
|
||||
t.x = zahl - '1';
|
||||
|
||||
if (t.x < 0 || t.x > 7) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
|
||||
if (t.y < 0 || t.y > 7) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
/**
|
||||
* @see java.lang.Object#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
|
||||
StringBuilder result = new StringBuilder();
|
||||
|
||||
char y = '1';
|
||||
|
||||
result.append(" ");
|
||||
for (char c : "abcdefgh".toCharArray()) {
|
||||
result.append(' ').append(c);
|
||||
}
|
||||
|
||||
result.append("\n");
|
||||
|
||||
for (Color[] figurs : brett) {
|
||||
|
||||
result.append(y++);
|
||||
|
||||
for (Color figur : figurs) {
|
||||
if (figur != null) {
|
||||
result.append(' ').append(figur);
|
||||
}
|
||||
else {
|
||||
result.append(" ");
|
||||
}
|
||||
}
|
||||
|
||||
result.append("\n");
|
||||
}
|
||||
|
||||
return result.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tupel von zwei int-Werten.
|
||||
*/
|
||||
private static class Tupel {
|
||||
int x;
|
||||
|
||||
int y;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
package pr2.io.serialisierung;
|
||||
|
||||
/**
|
||||
* Farben der Spielsteine.
|
||||
*/
|
||||
public enum Color {
|
||||
|
||||
/**
|
||||
* Schwarzer Stein.
|
||||
*/
|
||||
BLACK,
|
||||
|
||||
/**
|
||||
* Weißer Stein.
|
||||
*/
|
||||
WHITE;
|
||||
|
||||
/**
|
||||
* @see java.lang.Enum#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
if (this == Color.BLACK) {
|
||||
return "B";
|
||||
}
|
||||
else {
|
||||
return "W";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
package pr2.io.serialisierung.test;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import pr2.io.serialisierung.Board;
|
||||
import pr2.io.serialisierung.Color;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
/**
|
||||
* Test.
|
||||
*/
|
||||
public class BoardTest {
|
||||
|
||||
/**
|
||||
* Test für die Implementierung des Spielbrettes.
|
||||
*
|
||||
* @throws IOException Datei-Probleme.
|
||||
*/
|
||||
@Test
|
||||
void testDame() throws IOException {
|
||||
Board s = new Board();
|
||||
s.set("a1", Color.BLACK);
|
||||
s.set("b1", Color.WHITE);
|
||||
s.set("h1", Color.BLACK);
|
||||
s.set("h2", Color.BLACK);
|
||||
s.set("a8", Color.BLACK);
|
||||
s.set("f8", Color.BLACK);
|
||||
s.set("f5", Color.WHITE);
|
||||
s.set("e3", Color.WHITE);
|
||||
s.set("g2", Color.WHITE);
|
||||
|
||||
String stringRepresentation = s.toString();
|
||||
|
||||
s.writeToFile("/tmp/daten.dat");
|
||||
|
||||
s = Board.loadFromFile("/tmp/daten.dat");
|
||||
|
||||
assertEquals(stringRepresentation, s.toString());
|
||||
|
||||
s = Board.loadFromFile("pr2/io/serialisierung/testdata.dat");
|
||||
|
||||
assertEquals(stringRepresentation, s.toString());
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue