Update of exercises
Thomas Smits
parent
05285c4319
commit
890c0f1708
Binary file not shown.
|
Before Width: | Height: | Size: 242 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 68 KiB |
|
|
@ -1,131 +1,32 @@
|
|||
# Mist die Festplatte ist schon wieder voll
|
||||
# Eine Menge Mengen, bloß nicht vermengen
|
||||
|
||||
**🎓 Benotetes Assignment 🎓**
|
||||
|
||||
📆 **Fällig: 02.12.2025** 📆
|
||||
📆 **Fällig: 16.12.2025** 📆
|
||||
|
||||
Nachdem Sie den Reptiloiden "Never gonna give you up" vorgesungen haben und ein Bild von Rick Astley entgegen gehalten, sind diese wie zu Stein erstarrt und Sie können aus der Höhle flüchten. Hinter sich hören Sie noch das Grunzen und Schreien der Echsenwesen und glauben auch die Stimme von Mark Zuckerberg zu vernehmen. Nie wieder Facebook, Instagram und WhatsApp – das war einfach zu viel.
|
||||
Die Platte ist komprimiert, Battlefield 6 installiert und Sie zocken vor lauter Glück über Ihr tolles Kompressionsprogramm mehrere Nächte durch. Das Studium leidet, aber im Gegenzug steigen Sie immer weiter in den Rängen des Spiels auf. Wer braucht schon einen Bachelor of Science, wenn man sich durch 100 Ranks leveln kann.
|
||||
|
||||
Geschafft! Sie sind an der Erdoberfläche angekommen und schlagen sich nach Hause durch. Die Reise dauert durchaus eine Weile, auch wegen der ständig verspäteten Züge, und als Sie ankommen, brauchen Sie erst einmal etwas Entspannung.
|
||||
Plötzlich passiert es, Sie werden vom Sekundenschlaf erwischt und schlafen mit dem Kopf auf der Tastatur ein. Es war wohl doch zu viele die letzten Tage. Ihre Nase produziert wilde Zeichen im Discord-Chat und die anderen Spieler beschimpfen Sie auf Russisch. Aber Sie bekommen nichts mehr davon mit, so süß sind Ihre Träume.
|
||||
|
||||
Was kann mehr entspannen als ... eine Runde Battlefield 6.
|
||||
In Ihrem Traum werden Sie ins Wunderland verschleppt und der verrückte Hutmacher will, dass Sie ein Programm für ihn schreiben. Er wäre nicht der verrückte Hutmacher, wenn dieses Programm nicht sehr spezifische Anforderungen hätte. Oder ist es vielleicht gar nicht der Hutmacher, der Sie da quält?
|
||||
|
||||
|
||||
## MySet
|
||||
|
||||
Doch leider ist die Festplatte voll und der 67 GB Download passt nicht mehr drauf. Sie müssen dringend Platz schaffen! Also suchen Sie nach Möglichkeiten, die Daten auf Ihrer Festplatte, die eigentlich eine SSD ist, zu komprimieren.
|
||||
Gehen Sie in das Paket [pr2.generics.set](../sources/src/main/java/pr2/generics/set/).
|
||||
|
||||
Da kommt Ihnen die nächste PR2-Aufgabe gerade gelegen.
|
||||
Sie sollen das Interface `Set` implementieren, das die Operationen auf einer **Menge** definiert. Das Interface `Set` ist aber noch nicht generisch, d.h. bevor Sie die Implementierung beginnen, müssen Sie das Interface zu einem `Set<T>` umbauen, sodass man typsicher damit umgehen kann.
|
||||
|
||||
## CompressingOutputStream
|
||||
Ausgehend vom angepassten Interface `Set<T>` implementieren Sie die Methoden in der Klasse `MySet<T>`.
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.compressor](../sources/src/main/java/pr2/io/compressor/).
|
||||
Für die interne Speicherung der Daten verwenden Sie bitte die vorgegebene Klasse `Bag`, um sich die Arbeit zu erleichtern und nicht mit Arrays arbeiten zu müssen.
|
||||
|
||||
Implementieren Sie eine Klasse namens `CompressingOutputStream`, die von `FilterOutputStream` abgeleitet ist. Diese Klasse soll eine Komprimierung der Daten durchführen, wobei ein sogenanntes _run length encoding_ verwendet werden soll. Immer wenn ein Byte zwei- oder mehrmals hintereinander vorkommt, soll statt der wiederholten Bytes, die Sequenz `-1`, das Byte und die Anzahl der Wiederholungen geschrieben werden. So wird z.B. aus der Bytefolge `{ 5, 5, 5, 5, 5, 5, 5, 5, 5 }` durch die Kompression die Folge `{ -1, 5, 9 }`. Wiederholt sich ein Byte nicht, wird es einfach direkt übernommen. Es sind maximal 126 Wiederholungen möglich. Kommt ein Byte häufiger als 126-mal hintereinander vor, werden zuerst die ersten 126 Byte komprimiert und dann die nächsten Bytes bearbeitet. (Die Bytewerte sind hier als Dezimalzahlen angegeben, `-1` würde dann in hexadezimaler Darstellung `0xff` entsprechen.)
|
||||
Bitte beachten Sie die folgenden Regeln für die Implementierung:
|
||||
|
||||
Beachten Sie den Spezialfall, dass die Eingabedaten eine `-1` (`0xff`) enthalten, in diesem Fall müssen Sie die Escapesequenz `{ -1, -1 }` schreiben, um dies bei der Dekompression erkennen zu können. So wird z.B. aus der Eingabe `{ 3, -1, 5 }` komprimiert `{ 3, -1, -1, 5 }`.
|
||||
* Achten Sie bei den Methoden von `Set` darauf, dass diese **möglichst flexibel** mit den Typen umgehen, d.h. verwenden Sie, wo immer möglich, Wildcards anstatt des Typparameters `T`. Denken Sie an die Verwendung von `extends` und `super` im Zusammenhang mit Wildcards `?`.
|
||||
* Verwenden Sie **keine Klassen aus dem Collection API**, d.h. Sie dürfen nicht auf `java.util.Set`, `java.util.List` etc. zurückgreifen. Ihre darunterliegende Speicherung wird von `Bag` übernommen.
|
||||
* Implementieren Sie **zuerst die beiden Methoden** `each` und `test`.
|
||||
* Außerhalb der Methoden `each` und `test` darf es **keine Schleifen (`for`, `while`)** in Ihrer Klasse geben. Sie müssen alle Operationen, welche eine Iteration (Schleife) brauchen, auf diese beiden Methoden abbilden. Hierzu verwenden Sie bitte geschickt Lambdas, die Sie (wo sinnvoll) an die `each`- und `test`-Methode übergeben und darin dann die notwendigen Operationen durchführen.
|
||||
|
||||
Testen Sie Ihre Implementierung ausführlich mit Unit-Tests. Sie können folgende Bytefolgen als Startpunkt nehmen, sie sind aber auf keinen Fall ausreichend.
|
||||
## UnitTests
|
||||
|
||||
| Input | Komprimiert |
|
||||
|-----------------------------|-----------------------------|
|
||||
| `0, 1, 2, 3` | `0, 1, 2, 3` |
|
||||
| `-1, -1, -1` | `-1, -1, -1, -1, -1, -1` |
|
||||
| `-1, 1, 2, 3` | `-1, -1, 1, 2, 3` |
|
||||
| `0, 1, 1, 1, 1, 1, 1` | `0, -1, 1, 6` |
|
||||
| `5, 5, 5, 5, 5, 5, 5, 5, 5` | `-1, 5, 9` |
|
||||
| `0, 1, 1, 3, 3, 3, 3` | `0, -1, 1, 2, -1, 3, 4` |
|
||||
| `1, 1, 3, 3, 3, 3` | `-1, 1, 2, -1, 3, 4` |
|
||||
| `1, 2, 1, 3, 3, 3` | `1, 2, 1, -1, 3, 3` |
|
||||
| `1, 1, -1, 1, 2, 3` | `-1, 1, 2, -1, -1, 1, 2, 3` |
|
||||
| `1, 1, -1` | `-1, 1, 2, -1, -1` |
|
||||
| `-1` | `-1, -1` |
|
||||
| `-1, 1, 1` | `-1, -1, -1, 1, 2` |
|
||||
| `1, 1, 1, 1, 1, 1, 1, 1, 1` | `-1, 1, 9` |
|
||||
| `1, 1, 1, 1, -1` | `-1, 1, 4, -1, -1` |
|
||||
|
||||
|
||||
## DecompressingInputStream
|
||||
|
||||
Implementieren Sie eine Klasse namens `DecompressingInputStream`, die von `InputStream` abgeleitet ist. Diese Klasse soll eine Dekomprimierung der Daten durchführen, die vorher mit einem `CompressingOutputStream` komprimiert wurden.
|
||||
|
||||
Testen Sie Ihre Implementierung ausführlich mit Unit-Tests. Sie können die in der obigen Tabelle dargestellten Bytefolgen als Startpunkt nehmen, sollten aber noch mehr Fälle testen.
|
||||
|
||||
## FileCompressor
|
||||
|
||||
Implementieren Sie eine Klasse namens `FileCompressor`. Diese nimmt von der Kommandozeile zwei Argumente an, die zwei Dateien bezeichnen. Die zuerst angegebene Datei wird mithilfe eines `CompressingOutputStream` komprimiert und das Ergebnis wird in die als zweite Option angegebene Datei geschrieben. Denken Sie an eine sinnvolle Fehlerbehandlung.
|
||||
|
||||
Alternativ kann man die Klasse auch ohne Optionen aufrufen. In diesem Fall werden die Daten von der Standard-Eingabe gelesen und das komprimierte Ergebnis auf die Standard-Ausgabe geschrieben.
|
||||
|
||||
Diese letzte Anforderung bedeutet, dass man z.B. das folgende machen kann:
|
||||
|
||||
```console
|
||||
$ echo "Duuuuuuuuuuuuduuuuuuuuuu" | \
|
||||
java -cp . pr2.io.compressor.tool.FileCompressor > \
|
||||
result.rle
|
||||
```
|
||||
|
||||
|
||||
## FileDecompressor
|
||||
|
||||
Implementieren Sie eine Klasse namens `FileDecompressor`. Diese nimmt von der Kommandozeile zwei Argumente an, die zwei Dateien bezeichnen. Die zuerst angegebene Datei wird mithilfe eines `DecompressingInputStreams` dekomprimiert und das Ergebnis wird in die als zweite Option angegebene Datei geschrieben. Denken Sie an eine sinnvolle Fehlerbehandlung.
|
||||
|
||||
Alternativ kann man die Klasse auch ohne Optionen aufrufen. In diesem Fall werden die Daten von der Standard-Eingabe gelesen und das dekomprimierte Ergebnis auf die Standard-Ausgabe geschrieben.
|
||||
|
||||
Diese letzte Anforderung bedeutet, dass man z.B. das folgende machen kann:
|
||||
|
||||
```console
|
||||
$ echo "Duuuuuuuuuuuuduuuuuuuuuu" | \
|
||||
java -cp . pr2.io.compressor.tool.FileCompressor | \
|
||||
java -cp . pr2.io.compressor.tool.FileDecompressor
|
||||
Duuuuuuuuuuuuduuuuuuuuuu
|
||||
```
|
||||
|
||||
## DirectoryCompressor
|
||||
|
||||
Schreiben Sie eine Klasse namens `DirectoryCompressor`. Diese nimmt von der Kommandozeile den Namen eines Verzeichnisses entgegen und komprimiert alle darin gefundenen Dateien mit dem oben beschriebenen `FileCompressor`. Die komprimierten Dateien werden mit der Dateierweiterung `.rle` versehen, z.B. wird aus der Datei `MyFile.txt` die Datei `MyFile.txt.rle`. Die Originaldateien werden nicht verändert.
|
||||
|
||||
Beachten Sie die folgenden möglichen Fehlerfälle:
|
||||
|
||||
* Der Benutzer vergisst, einen Pfad anzugeben.
|
||||
* Das angegebene Verzeichnis existiert nicht.
|
||||
* Der angegebene Pfad ist gar kein Verzeichnis.
|
||||
* Das Verzeichnis existiert, darf aber nicht gelesen werden.
|
||||
* Das Verzeichnis existiert, darf aber nicht geschrieben werden.
|
||||
|
||||
Darüber hinaus können noch andere Fehler auftreten, die Sie bitte entsprechend abfangen und behandeln sollen.
|
||||
|
||||
Das Programm soll den Benutzer über seine Fortschritte informieren. Hierzu soll die Ausgabe ungefähr wie folgt aussehen:
|
||||
|
||||
```console
|
||||
Komprimiere Dateien in /Users/thomas/Temp/compressme
|
||||
|
||||
f1.txt (342 Bytes) -> f1.txt.rle (23 Bytes) [6%]
|
||||
f2.txt (1368 Bytes) -> f2.txt.rle (83 Bytes) [6%]
|
||||
f3.txt (13680 Bytes) -> f3.txt.rle (803 Bytes) [5%]
|
||||
```
|
||||
|
||||
## DirectoryDecompressor
|
||||
|
||||
Implementieren Sie eine Java-Klasse namens `DirectoryDecompressor`, die die Umkehroperation zum `DirectoryCompressor` zur Verfügung stellt. Man gibt ihr über die Kommandozeile einen Verzeichnisnamen und sie dekomprimiert alle darin gefundenen Dateien, die die Endung `.rle` haben.
|
||||
|
||||
Die komprimierten Dateien werden nach einer erfolgreichen Dekompression gelöscht.
|
||||
|
||||
Beachten Sie, dass auch hier unterschiedliche Fehler auftreten könne, die Sie bitte entsprechend abfangen und behandeln sollten.
|
||||
|
||||
Das Programm soll den Benutzer über seine Fortschritte informieren. Hierzu soll die Ausgabe ungefähr wie folgt aussehen:
|
||||
|
||||
```console
|
||||
Dekomprimiere Dateien in /Users/thomas/Temp/compressme2
|
||||
|
||||
f1.txt.rle (23 Bytes) -> f1.txt (342 Bytes)
|
||||
f2.txt.rle (83 Bytes) -> f2.txt (1368 Bytes)
|
||||
f3.txt.rle (803 Bytes) -> f3.txt (13680 Bytes)
|
||||
```
|
||||
|
||||
## Geheime Datei
|
||||
|
||||
Wenn Sie alles fertig implementiert haben, wenden Sie Ihre Software auf die Datei [bild.bmp.rle](files/bild.bmp.rle) an und dekomprimieren Sie sie.
|
||||
|
||||
* Was ist zu sehen?
|
||||
* Um welchen Faktor wurde die Datei komprimiert?
|
||||
* Warum ist der Kompressionsfaktor hier so hoch?
|
||||
Schreiben Sie JUnit-Tests in der Klasse [pr2.generics.set.TestMySet](../../solutions/src/test/java/pr2/generic/set/TestMySet), welche Ihre Implementierung ausgiebig testen. Hierbei sollten alle Methoden getestet werden, die das Interface vorgibt.
|
||||
|
|
@ -173,7 +173,7 @@ Wichtige Einstellungen für Eclipse sind [hier](help/eclipse.md) beschrieben.
|
|||
| 6. | 22.10.2025 | [Racewars](Assignment_006/readme.md) | **04.11.2025** |
|
||||
| 7. | 05.11.2025 | [Ein Traum in Zucker oder kann ich dem Zufallsgenerator trauen?](Assignment_007/readme.md) | **18.11.2025** |
|
||||
| 8. | 05.11.2025 | [Live-Testat](Assignment_008/readme.md) | **19.11.2025** |
|
||||
| 9. | 19.11.2025 | [Mist die Festplatte ist schon wieder voll](Assignment_009/readme.md) | **02.12.2025** |
|
||||
| 9. | 03.12.2025 | [Eine Menge Mengen, bloß nicht vermengen](Assignment_009/readme.md) | **16.12.2025** |
|
||||
## 😀 Freiwillige Übungen
|
||||
|
||||
Die freiwilligen Übungen zur Vertiefung der Vorlesungsinhalte finden Sie in einem getrennten Repository: [Freiwillige Übungen](/pr2-lecture/uebungen/src/branch/master/readme.md).
|
||||
|
|
|
|||
|
|
@ -119,6 +119,16 @@
|
|||
<scope>compile</scope>
|
||||
</dependency>
|
||||
-->
|
||||
<dependency>
|
||||
<groupId>com.googlecode.json-simple</groupId>
|
||||
<artifactId>json-simple</artifactId>
|
||||
<version>1.1</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.jline</groupId>
|
||||
<artifactId>jline</artifactId>
|
||||
<version>3.30.0</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>com.github.thomsmits</groupId>
|
||||
<artifactId> game-framework</artifactId>
|
||||
|
|
|
|||
|
|
@ -119,6 +119,16 @@
|
|||
<scope>compile</scope>
|
||||
</dependency>
|
||||
-->
|
||||
<dependency>
|
||||
<groupId>com.googlecode.json-simple</groupId>
|
||||
<artifactId>json-simple</artifactId>
|
||||
<version>1.1</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.jline</groupId>
|
||||
<artifactId>jline</artifactId>
|
||||
<version>3.30.0</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>com.github.thomsmits</groupId>
|
||||
<artifactId> game-framework</artifactId>
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ public class DrawRandom {
|
|||
|
||||
private static final int WIDTH = 100;
|
||||
private static final int HEIGHT = 100;
|
||||
private static final int ROUNDS = 1000000;
|
||||
private static final int ROUNDS = 100000000;
|
||||
|
||||
|
||||
public static void main(String[] args) throws IOException {
|
||||
|
|
|
|||
|
|
@ -265,7 +265,6 @@ public class SuperSecRandomGenerator implements RandomGenerator {
|
|||
;=::78:=@BDGILHFB<7767788778767767843689
|
||||
""".replace("\n", "").replace(" ", "");
|
||||
|
||||
|
||||
private final int[] seed;
|
||||
private final Random rnd;
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,110 @@
|
|||
package pr2.generics.set;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* Einfache Klasse zum Sammeln von Objekten.
|
||||
*/
|
||||
public class Bag {
|
||||
|
||||
private static final int INITIAL_CAPACITY = 10;
|
||||
private int pos = 0;
|
||||
|
||||
private Object[] data;
|
||||
|
||||
/**
|
||||
* Legt eine neue Instanz an.
|
||||
*/
|
||||
public Bag() {
|
||||
data = new Object[INITIAL_CAPACITY];
|
||||
}
|
||||
|
||||
/**
|
||||
* Fügt ein neues Element hinzu.
|
||||
* @param o das Element.
|
||||
*/
|
||||
public void add(Object o) {
|
||||
if (pos >= data.length) {
|
||||
Object[] newData = new Object[pos + INITIAL_CAPACITY];
|
||||
System.arraycopy(data, 0, newData, 0, pos);
|
||||
data = newData;
|
||||
}
|
||||
data[pos++] = o;
|
||||
}
|
||||
|
||||
/**
|
||||
* Liefert das Element am gegebenen Index.
|
||||
*
|
||||
* @param idx der Index.
|
||||
* @return das Element.
|
||||
*/
|
||||
public Object get(int idx) {
|
||||
if (idx >= data.length) {
|
||||
throw new IndexOutOfBoundsException("Index out of bounds: " + idx);
|
||||
}
|
||||
return data[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* Konvertiert die gespeicherten Daten in ein Array.
|
||||
*
|
||||
* @return ein Array.
|
||||
*/
|
||||
public Object[] toArray() {
|
||||
return Arrays.copyOf(data, pos);
|
||||
}
|
||||
|
||||
/**
|
||||
* Entfernt das Objekt am Index.
|
||||
*
|
||||
* @param idx Index.
|
||||
* @return das entfernte Objekt.
|
||||
*/
|
||||
public Object remove(int idx) {
|
||||
if (idx >= data.length) {
|
||||
throw new IndexOutOfBoundsException("Index out of bounds: " + idx);
|
||||
}
|
||||
Object o = data[idx];
|
||||
System.arraycopy(data, idx + 1, data, idx, data.length - idx - 1);
|
||||
pos--;
|
||||
return o;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gibt die Anzahl der gespeicherten Objekte zurück.
|
||||
*
|
||||
* @return Anzahl der Objekte.
|
||||
*/
|
||||
public int size() {
|
||||
return pos;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
Bag bag = (Bag) o;
|
||||
return pos == bag.pos && Objects.deepEquals(data, bag.data);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return Objects.hash(pos, Arrays.hashCode(data));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append("[");
|
||||
for (int i = 0; i < pos; i++) {
|
||||
sb.append(data[i]);
|
||||
if (i < pos - 1) {
|
||||
sb.append(", ");
|
||||
}
|
||||
}
|
||||
sb.append("]");
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
package pr2.generics.set;
|
||||
|
||||
|
||||
/**
|
||||
* Implementierung des Sets.
|
||||
*
|
||||
* @param <T> Typ der gespeicherten Daten
|
||||
*/
|
||||
public class MySet {
|
||||
|
||||
private Bag bag = new Bag();
|
||||
|
||||
// TODO: Methoden implementieren
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
package pr2.generics.set;
|
||||
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
/**
|
||||
* Verwaltung von Objektmengen.
|
||||
*
|
||||
* @param <T> Typ der gespeicherten Daten
|
||||
*/
|
||||
public interface Set {
|
||||
|
||||
/**
|
||||
* Fügt der Menge ein neues Element hinzu. Wenn das Element
|
||||
* bereits vorhanden ist, wird es nicht aufgenommen.
|
||||
*
|
||||
* @param obj das Objekt, das hinzugefügt werden soll.
|
||||
*/
|
||||
void add(Object obj);
|
||||
|
||||
/**
|
||||
* Entfernt das Objekt aus der Menge.
|
||||
*
|
||||
* @param obj das Objekt, das entfernt werden soll
|
||||
*/
|
||||
void remove(Object obj);
|
||||
|
||||
/**
|
||||
* Prüft, ob das Objekt in der Menge enthalten ist.
|
||||
*
|
||||
* @param obj das Objekt.
|
||||
* @return {@literal true}, wenn das Objekt enthalten
|
||||
* ist, andernfalls {@literal false}.
|
||||
*/
|
||||
boolean contains(Object obj);
|
||||
|
||||
/**
|
||||
* Gibt die Anzahl der gespeicherten Objekte zurück.
|
||||
*
|
||||
* @return die Anzahl.
|
||||
*/
|
||||
int size();
|
||||
|
||||
/**
|
||||
* Gibt ein neues Set zurück, dass die Vereinigungsmenge
|
||||
* aus diesem und dem anderen Set darstellt.
|
||||
*
|
||||
* @param other das andere set.
|
||||
* @return die Vereinigungsmenge.
|
||||
*/
|
||||
Set union(Set other);
|
||||
|
||||
/**
|
||||
* Bildet die Differenzmenge. D.h. aus diesem Set werden alle
|
||||
* Objekte entfernt, die in dem anderen Set enthalten sind.
|
||||
*
|
||||
* @param other das Set, das "abgezogen" werden soll
|
||||
* @return die Differenzmenge als neues Set.
|
||||
*/
|
||||
Set difference(Set other);
|
||||
|
||||
/**
|
||||
* Bildet die Schnittmenge. D.h. es werden nur die Elemente
|
||||
* behalten, die in beiden Sets vorhanden sind.
|
||||
*
|
||||
* @param other das andere Set.
|
||||
* @return die Schnittmenge.
|
||||
*/
|
||||
Set intersection(Set other);
|
||||
|
||||
/**
|
||||
* Filtert aus der Menge alle Elemente, die NICHT die
|
||||
* übergebene Bedingung erfüllen.
|
||||
*
|
||||
* @param p Bedingung.
|
||||
* @return das gefilterte Set.
|
||||
*/
|
||||
Set filter(Predicate p);
|
||||
|
||||
/**
|
||||
* Itertiert über die Menge und ruft für jedes
|
||||
* Element den Consumer auf.
|
||||
*
|
||||
* @param c der Consumer.
|
||||
*/
|
||||
void each(Consumer c);
|
||||
|
||||
/**
|
||||
* Kopiert dieses Set in das andere Set.
|
||||
*
|
||||
* @param other the target of the copy operation.
|
||||
*/
|
||||
void copyInto(Set other);
|
||||
|
||||
/**
|
||||
* Füllt dieses Set mit den Daten eines anderen
|
||||
* Sets.
|
||||
*
|
||||
* @param other das andere Set.
|
||||
*/
|
||||
void fillFrom(Set other);
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
package pr2.io.compressor;
|
||||
|
||||
import java.io.FilterOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
|
||||
/**
|
||||
* Stream implementation that performs an automatic run-length
|
||||
* encoding of the written data.
|
||||
*/
|
||||
public class CompressingOutputStream {
|
||||
|
||||
// TODO: Klasse implementieren
|
||||
}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
package pr2.io.compressor;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
/**
|
||||
* Stream that automatically decompresses data that was compressed
|
||||
* with the {@link CompressingOutputStream}.
|
||||
*/
|
||||
public class DecompressingInputStream {
|
||||
|
||||
// TODO: Klasse implementieren
|
||||
}
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
package pr2.io.compressor.tool;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileFilter;
|
||||
|
||||
/**
|
||||
* Compresses the content of a directory.
|
||||
*/
|
||||
public class DirectoryCompressor extends DirectoryToolBase {
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
|
||||
if (args.length != 1) {
|
||||
System.err.println("Bitte geben Sie ein Verzeichnis an.");
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
// TODO: Methode implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
package pr2.io.compressor.tool;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileFilter;
|
||||
|
||||
/**
|
||||
* Decompresses the content of a directory.
|
||||
*/
|
||||
public class DirectoryDecompressor extends DirectoryToolBase {
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
|
||||
if (args.length != 1) {
|
||||
System.err.println("Bitte geben Sie ein Verzeichnis an.");
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
// TODO: Methode implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
package pr2.io.compressor.tool;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
/**
|
||||
* Base class for all directory based tools.
|
||||
*/
|
||||
public class DirectoryToolBase {
|
||||
|
||||
// TODO: Gemeinsame Methoden für DirectoryCompressor und DirectoryDecompressor
|
||||
}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
package pr2.io.compressor.tool;
|
||||
|
||||
import pr2.io.compressor.CompressingOutputStream;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
|
||||
/**
|
||||
* Compresses a single file or stdin.
|
||||
*/
|
||||
public class FileCompressor {
|
||||
|
||||
public static void main(String... args) throws Exception {
|
||||
|
||||
// TODO: Methode implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
package pr2.io.compressor.tool;
|
||||
|
||||
import pr2.io.compressor.DecompressingInputStream;
|
||||
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
|
||||
/**
|
||||
* Decompresses a single file or stdin.
|
||||
*/
|
||||
public class FileDecompressor {
|
||||
|
||||
public static void main(String... args) throws Exception {
|
||||
|
||||
// TODO: Methode implementieren
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
package pr2.generics.set;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
|
||||
public class TestMySet {
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue