Zum Inhalt springen

Ströme und Ressourcen

Files.readAllLines liest eine Datei auf einmal in den Speicher. Für eine Einkaufsliste ist das ideal – für eine Logdatei mit zwei Millionen Zeilen nicht. Dann liest man Zeile für Zeile: Die Datei wird zu einem Strom von Daten, der vorbeifließt, und das Programm nimmt sich immer nur das nächste Stück.

  • eine Datei Zeile für Zeile lesen und schreiben
  • eine CSV-Datei einlesen und auswerten
  • die Dateien eines Ordners durchlaufen
  • erklären, was try-with-resources mit dem Interface AutoCloseable zu tun hat
  • erklären, warum aus Bytes erst mit dem richtigen Zeichensatz Text wird
  • Daten aus dem Netz als Strom lesen

Demo-Code: 23-stroeme

⤓ demo-stroeme.zip herunterladen

Der fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.

Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 23-stroeme wählen → OK → Trust Project. Zeigt IntelliJ oben Project JDK is not defined: auf Setup SDK klicken und das JDK 21 wählen.

Enthält: ZeilenLesen.java, ZeilenSchreiben.java, Ordner.java, Protokoll.java, RessourcenDemo.java, Zeichensaetze.java, Wikipedia.java, messwerte.csv, ausgaben.csv

Im Demo-Code liegen im Ordner daten zwei Beispieldateien: messwerte.csv und ausgaben.csv.

messwerte.csv ist eine CSV-Datei (comma-separated values): eine Tabelle als Text, eine Zeile pro Datensatz, die Spalten durch ein Trennzeichen getrennt. In Deutschland ist das meist ein Semikolon – das Komma steckt ja schon in den Zahlen.

daten/messwerte.csv (Anfang)
Datum;Ort;Temperatur
2026-10-12;Berlin;11.4
2026-10-12;Köln;13.1
2026-10-13;Berlin;9.8
ZeilenLesen.java
package de.drv.stroeme;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
/** Liest eine CSV-Datei Zeile für Zeile und wertet sie aus. */
public class ZeilenLesen {
public static void main(String[] args) throws IOException {
Path datei = Path.of("daten", "messwerte.csv");
int anzahl = 0;
double summe = 0;
double hoechster = Double.NEGATIVE_INFINITY;
String wo = "";
try (BufferedReader leser = Files.newBufferedReader(datei)) {
leser.readLine(); // die Kopfzeile überspringen
String zeile;
while ((zeile = leser.readLine()) != null) {
String[] teile = zeile.split(";");
double temperatur = Double.parseDouble(teile[2]);
anzahl++;
summe += temperatur;
if (temperatur > hoechster) {
hoechster = temperatur;
wo = teile[1] + " am " + teile[0];
}
}
}
System.out.printf("%d Messwerte, Durchschnitt %.1f °C%n", anzahl, summe / anzahl);
System.out.printf("am wärmsten: %.1f °C in %s%n", hoechster, wo);
}
}
Terminal-Fenster
10 Messwerte, Durchschnitt 11,8 °C
am wärmsten: 15,0 °C in Köln am 2026-10-16
  • Files.newBufferedReader(pfad) öffnet die Datei zum Lesen – in UTF-8, wie alle Methoden von Files.
  • readLine() liefert die nächste Zeile ohne das Zeilenende. Am Ende der Datei liefert es null.
  • Die Schleife while ((zeile = leser.readLine()) != null) sieht ungewohnt aus, ist aber die übliche Form: Sie liest eine Zeile, merkt sie sich in zeile und prüft im selben Schritt, ob überhaupt noch eine kam.
  • Im Speicher liegt immer nur eine Zeile. Das Programm funktioniert genauso mit zehn Zeilen wie mit zehn Millionen.
ZeilenSchreiben.java
package de.drv.stroeme;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
/** Schreibt eine Tabelle Zeile für Zeile in eine Datei. */
public class ZeilenSchreiben {
public static void main(String[] args) throws IOException {
Path datei = Path.of("daten", "einmaleins.txt");
try (PrintWriter schreiber = new PrintWriter(Files.newBufferedWriter(datei))) {
schreiber.println("Das kleine Einmaleins");
schreiber.println();
for (int zeile = 1; zeile <= 10; zeile++) {
for (int spalte = 1; spalte <= 10; spalte++) {
schreiber.printf("%4d", zeile * spalte);
}
schreiber.println();
}
}
System.out.println(Files.readAllLines(datei).size() + " Zeilen geschrieben nach " + datei);
}
}
Terminal-Fenster
12 Zeilen geschrieben nach daten\einmaleins.txt
daten/einmaleins.txt (Anfang)
Das kleine Einmaleins
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30

Files.newBufferedWriter(pfad) öffnet eine Datei zum Schreiben – eine vorhandene wird überschrieben. Drumherum legen wir einen PrintWriter. Er hat genau die Methoden, die du von System.out kennst: print, println und printf. Statt auf die Konsole schreiben sie in die Datei. println verwendet dabei das Zeilenende des Betriebssystems.

Eine geöffnete Datei belegt etwas im Betriebssystem. Solange sie offen ist, kann Windows sie zum Beispiel nicht löschen. Und was ein BufferedWriter geschrieben hat, landet erst beim Schließen sicher auf der Platte – vorher sammelt er es im Puffer. Vergisst ein Programm das Schließen, fehlt am Ende der Datei womöglich etwas.

Deshalb öffnen wir jede Datei in einem try-with-resources – du kennst es aus dem Kapitel Exceptions vom Scanner. Java schließt alles, was in den runden Klammern geöffnet wurde, am Ende des Blocks – auch wenn eine Exception auftritt.

Woher weiß Java, wie man einen Scanner, einen BufferedReader und einen PrintWriter schließt? Alle drei implementieren dasselbe Interface:

public interface AutoCloseable {
void close() throws Exception;
}

In die runden Klammern nach try darf alles, was AutoCloseable implementiert – auch eine eigene Klasse:

Protokoll.java
package de.drv.stroeme;
/** Eine eigene Ressource: Sie meldet, wann sie geöffnet und geschlossen wird. */
public class Protokoll implements AutoCloseable {
private final String name;
public Protokoll(String name) {
this.name = name;
System.out.println(name + " geöffnet");
}
public void schreibe(String text) {
System.out.println(name + ": " + text);
}
@Override
public void close() {
System.out.println(name + " geschlossen");
}
}
RessourcenDemo.java
package de.drv.stroeme;
public class RessourcenDemo {
public static void main(String[] args) {
// Zwei Ressourcen in einem try: geschlossen wird in umgekehrter Reihenfolge.
try (Protokoll eins = new Protokoll("A"); Protokoll zwei = new Protokoll("B")) {
eins.schreibe("Hallo");
zwei.schreibe("Welt");
}
System.out.println();
// Auch bei einer Exception wird geschlossen – noch bevor catch drankommt.
try (Protokoll protokoll = new Protokoll("C")) {
protokoll.schreibe("gleich geht etwas schief");
throw new IllegalStateException("Absicht");
} catch (IllegalStateException e) {
System.out.println("gefangen: " + e.getMessage());
}
}
}
Terminal-Fenster
A geöffnet
B geöffnet
A: Hallo
B: Welt
B geschlossen
A geschlossen
C geöffnet
C: gleich geht etwas schief
C geschlossen
gefangen: Absicht
  • Mehrere Ressourcen stehen durch Semikolon getrennt in den Klammern. Geschlossen wird in umgekehrter Reihenfolge – was zuletzt geöffnet wurde, wird zuerst geschlossen.
  • Bei einer Exception wird zuerst geschlossen, dann kommt der catch-Block dran.
  • Unser close() wirft keine Exception – deshalb lassen wir das throws Exception weg. Eine Implementierung darf weniger Exceptions werfen, als das Interface erlaubt, aber nicht mehr.
Ordner.java
package de.drv.stroeme;
import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
/** Listet die Dateien eines Ordners mit ihrer Größe auf – wie dir. */
public class Ordner {
public static void main(String[] args) throws IOException {
Path ordner = Path.of(args.length > 0 ? args[0] : "daten");
int anzahl = 0;
long gesamt = 0;
try (DirectoryStream<Path> eintraege = Files.newDirectoryStream(ordner, "*.csv")) {
for (Path eintrag : eintraege) {
long groesse = Files.size(eintrag);
System.out.printf("%-20s %8d Bytes%n", eintrag.getFileName(), groesse);
anzahl++;
gesamt += groesse;
}
}
System.out.printf("%d Dateien, zusammen %d Bytes%n", anzahl, gesamt);
}
}
Terminal-Fenster
ausgaben.csv 378 Bytes
messwerte.csv 244 Bytes
2 Dateien, zusammen 622 Bytes
  • Files.newDirectoryStream(ordner, "*.csv") liefert die Einträge eines Ordners, hier nur die mit der Endung .csv. Ohne das zweite Argument kommen alle.
  • Ein DirectoryStream ist ein Iterable – deshalb funktioniert die for-each-Schleife, wie bei einer List. Und er ist AutoCloseable, denn auch ein geöffneter Ordner muss wieder geschlossen werden.
  • In welcher Reihenfolge die Einträge kommen, ist nicht festgelegt. Wer sie sortiert braucht, sammelt sie zuerst – zum Beispiel in einem TreeSet.

Alles, was wir bisher gelesen haben, war Text. Daneben gibt es Dateien aus Bytes: Bilder, PDFs, ZIP-Archive. Java trennt beides sauber:

liest schreibt öffnen mit
Zeichen (Text) Reader, BufferedReader Writer, BufferedWriter, PrintWriter Files.newBufferedReader / newBufferedWriter
Bytes InputStream OutputStream Files.newInputStream / newOutputStream

Reader, Writer, InputStream und OutputStream sind abstrakte Klassen, wie wir sie in Woche 1 kennengelernt haben. Es gibt viele Unterklassen – für Dateien, für Netzwerkverbindungen, für Daten im Speicher. Wer gegen InputStream programmiert, kann aus all diesen Quellen lesen.

Für Bytes brauchen wir die Ströme selten selbst: Zum Kopieren gibt es Files.copy, und das Lesen von Bildern oder ZIP-Dateien übernehmen fertige Klassen.

Eine Datei, eine Netzwerkverbindung, ein Speicherbereich – sie alle liefern Bytes. Text wird daraus erst, wenn jemand weiß, nach welcher Regel die Bytes Zeichen bedeuten: dem Zeichensatz (Charset). Bei Files war das immer UTF-8, und wir mussten nicht darüber nachdenken. Sobald die Bytes von woanders kommen, müssen wir es.

Zeichensaetze.java
package de.drv.stroeme;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.HexFormat;
/** Aus Zeichen werden Bytes – und mit dem falschen Zeichensatz wieder falsche Zeichen. */
public class Zeichensaetze {
public static void main(String[] args) throws IOException {
String text = "Müller zahlt 5 €";
byte[] utf8 = text.getBytes(StandardCharsets.UTF_8);
System.out.println(text.length() + " Zeichen, aber " + utf8.length + " Bytes in UTF-8:");
System.out.println(HexFormat.ofDelimiter(" ").withUpperCase().formatHex(utf8));
// Dieselben Bytes, dreimal gelesen – nur einmal mit dem richtigen Zeichensatz
System.out.println("als UTF-8: " + lies(utf8, StandardCharsets.UTF_8));
System.out.println("als ISO-8859-1: " + lies(utf8, StandardCharsets.ISO_8859_1));
System.out.println("als US-ASCII: " + lies(utf8, StandardCharsets.US_ASCII));
}
/** Liest Bytes über einen Strom – so, wie sie auch aus einer Datei oder dem Netz kämen. */
private static String lies(byte[] bytes, Charset zeichensatz) throws IOException {
InputStream strom = new ByteArrayInputStream(bytes);
try (BufferedReader leser = new BufferedReader(new InputStreamReader(strom, zeichensatz))) {
return leser.readLine();
}
}
}
Terminal-Fenster
16 Zeichen, aber 19 Bytes in UTF-8:
4D C3 BC 6C 6C 65 72 20 7A 61 68 6C 74 20 35 20 E2 82 AC
als UTF-8: Müller zahlt 5 €
als ISO-8859-1: Müller zahlt 5 â¬
als US-ASCII: M��ller zahlt 5 ���
  • In UTF-8 braucht ein M ein Byte (4D), ein ü zwei (C3 BC) und das € sogar drei (E2 82 AC). 16 Zeichen werden so zu 19 Bytes.
  • ISO-8859-1 – ein alter Zeichensatz für westeuropäische Sprachen – kennt nur ein Byte pro Zeichen. Aus C3 BC werden zwei Zeichen: ü. Aus dem € werden drei – das mittlere ist ein unsichtbares Steuerzeichen. Diesen Salat hast du bestimmt schon in E-Mails oder auf Webseiten gesehen. Dahinter steckt fast immer dieser Fehler: Text als UTF-8 geschrieben, aber anders gelesen.
  • US-ASCII kennt gar keine Umlaute. Was es nicht versteht, ersetzt Java durch �.
  • Den Zeichensatz bekommt der InputStreamReader mit: Er ist die Brücke von einem InputStream (Bytes) zu einem Reader (Zeichen). Ein ByteArrayInputStream liefert dabei die Bytes aus einem Array – so, als kämen sie aus einer Datei.

Jetzt kommen die Bytes wirklich von woanders: von einem Server im Internet. Wikipedia bietet eine öffentliche Schnittstelle, die für jeden Artikel eine Kurzbeschreibung liefert. Seit Java 11 gehört ein HttpClient zum JDK, mit dem wir sie abrufen:

Wikipedia.java
package de.drv.stroeme;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
/** Holt die Kurzbeschreibung eines Wikipedia-Artikels – als Strom aus dem Netz. */
public class Wikipedia {
public static void main(String[] args) throws IOException, InterruptedException {
String titel = args.length > 0 ? String.join(" ", args) : "Köln";
// Leerzeichen werden bei Wikipedia zu _, Umlaute müssen in der Adresse kodiert werden
String kodiert = URLEncoder.encode(titel.replace(' ', '_'), StandardCharsets.UTF_8);
URI adresse = URI.create("https://de.wikipedia.org/api/rest_v1/page/summary/" + kodiert);
System.out.println("GET " + adresse);
HttpRequest anfrage = HttpRequest.newBuilder(adresse)
.header("User-Agent", "Java-Schulung (https://java.lean-stack.rocks)")
.build();
try (HttpClient client = HttpClient.newHttpClient()) {
// Die Antwort kommt als InputStream – also als Bytes
HttpResponse<InputStream> antwort = client.send(anfrage, HttpResponse.BodyHandlers.ofInputStream());
System.out.println("Status: " + antwort.statusCode());
System.out.println("Content-Type: " + antwort.headers().firstValue("Content-Type").orElse("?"));
if (antwort.statusCode() != 200) {
antwort.body().close(); // auch eine Antwort, die wir nicht lesen, wird geschlossen
System.out.println("Keinen Artikel gefunden: " + titel);
return;
}
// Erst der InputStreamReader macht mit dem richtigen Zeichensatz Text daraus
StringBuilder json = new StringBuilder();
try (BufferedReader leser = new BufferedReader(
new InputStreamReader(antwort.body(), StandardCharsets.UTF_8))) {
String zeile;
while ((zeile = leser.readLine()) != null) {
json.append(zeile);
}
}
System.out.println(json.length() + " Zeichen JSON");
System.out.println();
System.out.println(feld(json.toString(), "extract"));
}
}
/** Sucht ein Textfeld in einem JSON-Text – ganz einfach, ohne Bibliothek. */
private static String feld(String json, String name) {
String suche = "\"" + name + "\":\"";
int anfang = json.indexOf(suche);
if (anfang < 0) {
return "(kein Feld " + name + ")";
}
anfang += suche.length();
int ende = json.indexOf("\"", anfang);
return json.substring(anfang, ende);
}
}
Terminal-Fenster
GET https://de.wikipedia.org/api/rest_v1/page/summary/K%C3%B6ln
Status: 200
Content-Type: application/json; charset=utf-8; profile="https://www.mediawiki.org/wiki/Specs/Summary/1.5.0"
2046 Zeichen JSON
Köln ist eine kreisfreie Stadt im Land Nordrhein-Westfalen mit rund einer Million Einwohnern. Sie ist die bevölkerungsreichste Gemeinde des Bundeslandes und die viertgrößte Deutschlands.

(Die Zahl der Zeichen und der Text ändern sich, wenn jemand den Artikel bearbeitet.)

  • Die Adresse darf keine Umlaute und Leerzeichen enthalten. URLEncoder.encode kodiert sie – und zwar ebenfalls mit einem Zeichensatz: Aus ö werden die beiden UTF-8-Bytes C3 B6, geschrieben als %C3%B6.
  • Die Antwort holen wir mit BodyHandlers.ofInputStream() als InputStream – als Bytes, wie aus einer Datei. Welcher Zeichensatz gilt, sagt der Server im Kopf der Antwort: Content-Type: … charset=utf-8. Genau den geben wir dem InputStreamReader.
  • Zwei Ressourcen stehen in einem try: Der HttpClient ist seit Java 21 selbst AutoCloseable, und der Leser schließt beim Schließen den Strom der Antwort.
  • Der Status sagt, ob es geklappt hat: 200 heißt OK, 404 nicht gefunden. Dann lesen wir die Antwort nicht – geschlossen wird ihr Strom trotzdem.
  • InterruptedException: send wartet auf den Server, und wer wartet, kann unterbrochen werden. Was das genau bedeutet, sehen wir beim Thema Parallelität.

Die Antwort ist JSON, ein verbreitetes Textformat für Daten. Unser feld sucht darin ganz einfach mit indexOf. Das klappt für dieses Beispiel – für echte Programme nimmt man eine Bibliothek, die JSON richtig versteht. Wie man Bibliotheken bequem einbindet, zeigt das Kapitel Maven.

Arbeite im Projekt 23-stroeme. Jede Datei öffnest du mit try-with-resources.

  1. Nummerieren: Das Programm Nummerieren bekommt einen Dateinamen und schreibt eine Kopie, in der vor jeder Zeile ihre Nummer steht – aus messwerte.csv wird nummeriert-messwerte.csv im selben Ordner. Öffne dafür Leser und Schreiber im selben try.

    daten/nummeriert-messwerte.csv (Anfang)
    1 Datum;Ort;Temperatur
    2 2026-10-12;Berlin;11.4
    3 2026-10-12;Köln;13.1

    Tipp: pfad.resolveSibling(name) liefert einen Pfad mit anderem Namen im selben Ordner.

  2. Haushaltsbuch: Das Programm Haushaltsbuch liest daten\ausgaben.csv und summiert die Beträge je Kategorie. Das Ergebnis schreibt es alphabetisch sortiert in die Datei daten\auswertung.txt – mit einer Zeile Gesamt am Ende. Welche Sammlung passt für „Kategorie → Summe, sortiert“?

  3. Robust: In ausgaben.csv stecken zwei fehlerhafte Zeilen. Statt abzubrechen, meldet das Programm jede fehlerhafte Zeile mit ihrer Zeilennummer auf der Konsole und macht mit der nächsten weiter.

    Terminal-Fenster
    Zeile 7 übersprungen, kein Betrag: 2026-10-07;Lebensmittel;zwölf
    Zeile 10 übersprungen, nicht drei Felder: 2026-10-10;Kino
    Auswertung geschrieben: daten\auswertung.txt
  4. Für Schnelle: Das Programm Tail gibt die letzten n Zeilen einer Datei aus – wie das Linux-Programm tail. Aufruf: Tail 3 daten\messwerte.csv. Es darf nie mehr als n Zeilen im Speicher halten, auch bei einer riesigen Datei. Welche Sammlung aus dem Collection-Kapitel passt dazu? (Wer sein RollendesArray zur Hand hat: Genau dafür ist es gebaut.)

  5. Für Neugierige: Starte Wikipedia mit eigenen Begriffen als Argumenten, etwa Düsseldorf oder Straßenbahn. Probiere dann zwei Dinge aus und beobachte, was passiert:

    • Ersetze im InputStreamReader UTF_8 durch ISO_8859_1.
    • Lass URLEncoder.encode weg und setze den Titel direkt in die Adresse.
Lösung

Beide Ressourcen stehen im selben try, durch ein Semikolon getrennt. Geschlossen wird zuerst der Schreiber, dann der Leser.

Nummerieren.java
package de.drv.stroeme;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
/** Stufe 1: schreibt eine Kopie einer Datei mit Zeilennummern. */
public class Nummerieren {
public static void main(String[] args) throws IOException {
if (args.length != 1) {
System.out.println("Aufruf: Nummerieren <Datei>");
return;
}
Path quelle = Path.of(args[0]);
String name = quelle.getFileName().toString();
Path ziel = quelle.resolveSibling("nummeriert-" + name);
int nummer = 0;
try (BufferedReader leser = Files.newBufferedReader(quelle);
PrintWriter schreiber = new PrintWriter(Files.newBufferedWriter(ziel))) {
String zeile;
while ((zeile = leser.readLine()) != null) {
nummer++;
schreiber.printf("%3d %s%n", nummer, zeile);
}
}
System.out.println(nummer + " Zeilen nummeriert: " + ziel);
}
}
Lösung
daten/auswertung.txt
Ausgaben nach Kategorie
Fahrtkosten 62,40 €
Freizeit 56,40 €
Lebensmittel 151,28 €
Miete 650,00 €
Versicherung 23,80 €
Gesamt 943,88 €
  • Eine TreeMap<String, Double> sammelt die Summen und sortiert die Kategorien gleich mit.
  • Für die zwei Fehlerarten gibt es zwei Prüfungen: Die Zahl der Felder prüft teile.length vorher, einen ungültigen Betrag meldet parseDouble mit einer NumberFormatException. continue springt direkt zur nächsten Zeile.
  • Die Zeilennummer beginnt bei 1 für die Kopfzeile – so stimmt sie mit der Anzeige im Editor überein.
  • Die Beträge sind hier double. Für ein echtes Haushaltsbuch nähme man wie in Woche 1 einen Betrag in Cent – bei double können sich Rundungsfehler aufsummieren.
Haushaltsbuch.java
package de.drv.stroeme;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.TreeMap;
/** Stufen 2 und 3: summiert die Ausgaben je Kategorie und schreibt eine Auswertung. */
public class Haushaltsbuch {
public static void main(String[] args) throws IOException {
Path quelle = Path.of("daten", "ausgaben.csv");
Path ziel = Path.of("daten", "auswertung.txt");
Map<String, Double> summen = new TreeMap<>();
int nummer = 1; // die Kopfzeile ist Zeile 1
try (BufferedReader leser = Files.newBufferedReader(quelle)) {
leser.readLine();
String zeile;
while ((zeile = leser.readLine()) != null) {
nummer++;
String[] teile = zeile.split(";");
if (teile.length != 3) {
System.out.println("Zeile " + nummer + " übersprungen, nicht drei Felder: " + zeile);
continue;
}
try {
double betrag = Double.parseDouble(teile[2]);
summen.put(teile[1], summen.getOrDefault(teile[1], 0.0) + betrag);
} catch (NumberFormatException e) {
System.out.println("Zeile " + nummer + " übersprungen, kein Betrag: " + zeile);
}
}
}
double gesamt = 0;
try (PrintWriter schreiber = new PrintWriter(Files.newBufferedWriter(ziel))) {
schreiber.println("Ausgaben nach Kategorie");
schreiber.println();
for (Map.Entry<String, Double> eintrag : summen.entrySet()) {
schreiber.printf("%-15s %10.2f €%n", eintrag.getKey(), eintrag.getValue());
gesamt += eintrag.getValue();
}
schreiber.printf("%-15s %10.2f €%n", "Gesamt", gesamt);
}
System.out.println("Auswertung geschrieben: " + ziel);
}
}
Lösung
Terminal-Fenster
2026-10-15;Köln;14.2
2026-10-16;Berlin;12.7
2026-10-16;Köln;15.0

Eine ArrayDeque als Warteschlange: Jede Zeile kommt hinten hinein, und sobald es mehr als n sind, fällt vorn die älteste heraus. Genau das Verhalten unseres RollendesArray.

Tail.java
package de.drv.stroeme;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayDeque;
import java.util.Deque;
/** Stufe 4: die letzten n Zeilen einer Datei – wie tail unter Linux. */
public class Tail {
public static void main(String[] args) throws IOException {
if (args.length != 2) {
System.out.println("Aufruf: Tail <Anzahl> <Datei>");
return;
}
int anzahl = Integer.parseInt(args[0]);
// Nie mehr als anzahl Zeilen im Speicher – egal, wie groß die Datei ist
Deque<String> letzte = new ArrayDeque<>();
try (BufferedReader leser = Files.newBufferedReader(Path.of(args[1]))) {
String zeile;
while ((zeile = leser.readLine()) != null) {
letzte.addLast(zeile);
if (letzte.size() > anzahl) {
letzte.removeFirst();
}
}
}
for (String zeile : letzte) {
System.out.println(zeile);
}
}
}
Lösung
  • Mit ISO_8859_1 kommt der Text noch an, aber jeder Umlaut wird zu zwei falschen Zeichen: „Köln ist eine kreisfreie Stadt …“. Die Bytes sind dieselben, nur die Regel zum Lesen ist falsch.
  • Ohne URLEncoder klappt Straßenbahn sogar – Java kodiert Umlaute und ß beim Senden selbst. Bei zwei Wörtern wie Deutsche Bahn aber wirft URI.create eine IllegalArgumentException: Illegal character in path. Ein Leerzeichen darf in einer Adresse nicht vorkommen, und Zeichen wie ? oder # hätten dort eine eigene Bedeutung. Wer selbst kodiert, weiß, was geschickt wird.