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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- 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
AutoCloseablezu 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 herunterladenDer 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.
Zeile für Zeile lesen
Abschnitt betitelt „Zeile für Zeile lesen“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.
Datum;Ort;Temperatur2026-10-12;Berlin;11.42026-10-12;Köln;13.12026-10-13;Berlin;9.8package 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); }
}10 Messwerte, Durchschnitt 11,8 °Cam wärmsten: 15,0 °C in Köln am 2026-10-16Files.newBufferedReader(pfad)öffnet die Datei zum Lesen – in UTF-8, wie alle Methoden vonFiles.readLine()liefert die nächste Zeile ohne das Zeilenende. Am Ende der Datei liefert esnull.- Die Schleife
while ((zeile = leser.readLine()) != null)sieht ungewohnt aus, ist aber die übliche Form: Sie liest eine Zeile, merkt sie sich inzeileund 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.
Zeile für Zeile schreiben
Abschnitt betitelt „Zeile für Zeile schreiben“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); }
}12 Zeilen geschrieben nach daten\einmaleins.txtDas 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 30Files.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.
Warum immer try (…)?
Abschnitt betitelt „Warum immer try (…)?“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.
Der Vertrag dahinter: AutoCloseable
Abschnitt betitelt „Der Vertrag dahinter: AutoCloseable“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:
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"); }
}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()); } }
}A geöffnetB geöffnetA: HalloB: WeltB geschlossenA geschlossen
C geöffnetC: gleich geht etwas schiefC geschlossengefangen: 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 dasthrows Exceptionweg. Eine Implementierung darf weniger Exceptions werfen, als das Interface erlaubt, aber nicht mehr.
Einen Ordner durchlaufen
Abschnitt betitelt „Einen Ordner durchlaufen“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); }
}ausgaben.csv 378 Bytesmesswerte.csv 244 Bytes2 Dateien, zusammen 622 BytesFiles.newDirectoryStream(ordner, "*.csv")liefert die Einträge eines Ordners, hier nur die mit der Endung.csv. Ohne das zweite Argument kommen alle.- Ein
DirectoryStreamist einIterable– deshalb funktioniert die for-each-Schleife, wie bei einerList. Und er istAutoCloseable, 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.
Bytes und Zeichen
Abschnitt betitelt „Bytes und Zeichen“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.
Vom Byte zum Zeichen
Abschnitt betitelt „Vom Byte zum Zeichen“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.
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(); } }
}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 ACals 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
Mein 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 BCwerden 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
InputStreamReadermit: Er ist die Brücke von einemInputStream(Bytes) zu einemReader(Zeichen). EinByteArrayInputStreamliefert dabei die Bytes aus einem Array – so, als kämen sie aus einer Datei.
Ströme aus dem Netz
Abschnitt betitelt „Ströme aus dem Netz“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:
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); }
}GET https://de.wikipedia.org/api/rest_v1/page/summary/K%C3%B6lnStatus: 200Content-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.encodekodiert sie – und zwar ebenfalls mit einem Zeichensatz: Ausöwerden die beiden UTF-8-BytesC3 B6, geschrieben als%C3%B6. - Die Antwort holen wir mit
BodyHandlers.ofInputStream()alsInputStream– 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 demInputStreamReader. - Zwei Ressourcen stehen in einem
try: DerHttpClientist seit Java 21 selbstAutoCloseable, und der Leser schließt beim Schließen den Strom der Antwort. - Der Status sagt, ob es geklappt hat:
200heißt OK,404nicht gefunden. Dann lesen wir die Antwort nicht – geschlossen wird ihr Strom trotzdem. InterruptedException:sendwartet 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.
Übung: Zeile für Zeile
Abschnitt betitelt „Übung: Zeile für Zeile“Arbeite im Projekt 23-stroeme. Jede Datei öffnest du mit try-with-resources.
-
Nummerieren: Das Programm
Nummerierenbekommt einen Dateinamen und schreibt eine Kopie, in der vor jeder Zeile ihre Nummer steht – ausmesswerte.csvwirdnummeriert-messwerte.csvim selben Ordner. Öffne dafür Leser und Schreiber im selbentry.daten/nummeriert-messwerte.csv (Anfang) 1 Datum;Ort;Temperatur2 2026-10-12;Berlin;11.43 2026-10-12;Köln;13.1Tipp:
pfad.resolveSibling(name)liefert einen Pfad mit anderem Namen im selben Ordner. -
Haushaltsbuch: Das Programm
Haushaltsbuchliestdaten\ausgaben.csvund summiert die Beträge je Kategorie. Das Ergebnis schreibt es alphabetisch sortiert in die Dateidaten\auswertung.txt– mit einer Zeile Gesamt am Ende. Welche Sammlung passt für „Kategorie → Summe, sortiert“? -
Robust: In
ausgaben.csvstecken 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ölfZeile 10 übersprungen, nicht drei Felder: 2026-10-10;KinoAuswertung geschrieben: daten\auswertung.txt -
Für Schnelle: Das Programm
Tailgibt die letzten n Zeilen einer Datei aus – wie das Linux-Programmtail. 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 seinRollendesArrayzur Hand hat: Genau dafür ist es gebaut.) -
Für Neugierige: Starte
Wikipediamit eigenen Begriffen als Argumenten, etwaDüsseldorfoderStraßenbahn. Probiere dann zwei Dinge aus und beobachte, was passiert:- Ersetze im
InputStreamReaderUTF_8durchISO_8859_1. - Lass
URLEncoder.encodeweg und setze den Titel direkt in die Adresse.
- Ersetze im
Lösung
Beide Ressourcen stehen im selben try, durch ein Semikolon getrennt. Geschlossen
wird zuerst der Schreiber, dann der Leser.
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
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.lengthvorher, einen ungültigen Betrag meldetparseDoublemit einerNumberFormatException.continuespringt 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 einenBetragin Cent – beidoublekönnen sich Rundungsfehler aufsummieren.
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
2026-10-15;Köln;14.22026-10-16;Berlin;12.72026-10-16;Köln;15.0Eine 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.
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_1kommt 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
URLEncoderklapptStraßenbahnsogar – Java kodiert Umlaute undßbeim Senden selbst. Bei zwei Wörtern wieDeutsche Bahnaber wirftURI.createeineIllegalArgumentException: 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.