Java String-Formatierung: String.format und printf

Konkatenation (+) eignet sich gut für kurze, einfache Strings. Sobald man eine Zahl auf eine bestimmte Anzahl von Dezimalstellen runden, Spalten durch Auffüllen ausrichten, ein Datum in konsistentem Format einbetten oder Werte allgemein formatieren statt nur einfügen möchte, greift man auf die printf-artige API zurück, die Java von C übernommen hat.

Es gibt drei eng verwandte Einstiegspunkte, die alle im echten Code vorkommen:

String.format(fmt, args...) — gibt einen formatierten String zurück.
"...".formatted(args...) — Instanzform, hinzugefügt in Java 15. Identisches Ergebnis, besser geeignet zum Verketten.
System.out.printf(fmt, args...) — gibt direkt auf einen PrintStream (oder einen beliebigen Formatter) aus.

Alle drei teilen dieselbe Formatspezifizierer-Syntax. Einmal lernen, überall anwenden.

Formatspezifizierer

Ein Spezifizierer hat die Form %[flags][width][.precision]conversion. Der Konvertierungsbuchstabe ist das einzige Pflichtfeld. Der Rest steuert Breite, Ausrichtung, Auffüllung und Präzision.

String s = String.format("%-10s | %5d | %8.2f", "apples", 42, 3.14159);
// "apples     |    42 |     3.14"

Die nützlichsten Konvertierungen:

Konvertierung	Argument	Bedeutung
`%s`	beliebig	`toString()` des Werts
`%d`	ganzzahlig	Dezimalzahl
`%f`	Gleitkommazahl	Festkommadarstellung
`%e`	Gleitkommazahl	wissenschaftliche Notation
`%g`	Gleitkommazahl	kürzere Darstellung aus `%e` und `%f`
`%x`, `%o`	ganzzahlig	Hexadezimal / Oktal
`%c`	Zeichen	einzelnes Zeichen
`%b`	beliebig	`true`/`false` (null → `"false"`)
`%n`	keins	plattformspezifisches Zeilentrennzeichen
`%%`	keins	ein literales `%`
`%t...`	Datum/Uhrzeit	eine ganze Familie — `%tF`, `%tT`, usw.

Die Breite füllt die Ausgabe auf mindestens N Zeichen auf; die Präzision bedeutet „Dezimalstellen" bei Gleitkommazahlen und „maximale Zeichenanzahl" bei Strings.

Flags: Ausrichtung, Vorzeichen, Nullauffüllung, Gruppierung

Eine Handvoll Flags steht zwischen % und der Breite:

- — linksbündig in der Breite ausrichten. Standardmäßig rechtsbündig.
0 — mit Nullen auf die Breite auffüllen (nur bei numerischen Konvertierungen).
+ — bei Zahlen immer ein Vorzeichen anzeigen (+42, -7).
(Leerzeichen) — bei positiven Zahlen ein führendes Leerzeichen anzeigen, ähnlich wie +, aber mit einem Leerzeichen.
, — Stellen mit dem tausender Trennzeichen des Gebietsschemas gruppieren.
( — negative Zahlen in Klammern einschließen, im Buchhaltungsstil.

String.format("%08d", 42);        // "00000042"
String.format("%,d", 1234567);    // "1,234,567"
String.format("%+.2f", 3.14159);  // "+3.14"
String.format("%-10s|", "hi");    // "hi        |"

Breite und Präzision

Breite ist die Mindest-Feldbreite — wenn der formatierte Wert breiter ist, wird nichts abgeschnitten.

Präzision bedeutet je nach Konvertierung unterschiedliches:

%.3f — drei Stellen nach dem Dezimalpunkt.
%.10s — den String auf höchstens 10 Zeichen kürzen.
%.4e — vier Stellen Mantissenpräzision.

Breite und Präzision zu kombinieren ist üblich, wenn Spalten ausgerichtet und Zahlen gerundet sein sollen:

String.format("%10.4f", Math.PI);   // "    3.1416"
String.format("%-10.4s", "abcdef"); // "abcd      "

`%n` vs. `\n`

%n gibt das plattformspezifische Zeilentrennzeichen aus: "\n" unter Unix, "\r\n" unter Windows. \n ist immer genau ein Byte. Für Dateien und Protokollausgaben, bei denen das Zeilenende präzise vorgegeben ist, ist \n vorzuziehen und bewusst zu wählen. Für Konsolenausgaben, die auf dem jeweiligen Betriebssystem, auf dem die JVM läuft, korrekt aussehen sollen, ist %n die sicherere Wahl.

Argumentindizes: Wiederverwendung und Neuanordnung

Ein Spezifizierer der Form %N$... bezieht sich auf das N-te Argument (1-basiert). Nützlich, wenn ein Wert mehr als einmal in einer Vorlage erscheint oder wenn die natürliche Lesereihenfolge von der Argumentreihenfolge abweicht:

String.format("%1$s, %1$s, %1$s!", "go");        // "go, go, go!"
String.format("%2$s before %1$s", "lunch", "tea"); // "tea before lunch"

Dies ist das richtige Werkzeug beim Lokalisieren von Vorlagen — verschiedene Sprachen stellen Substantive an unterschiedliche Positionen, und ein Übersetzer kann Platzhalter neu anordnen, ohne die Aufrufstelle anzufassen.

Gebietsschema beeinflusst Zahlen und Datumsangaben

Die Zahlenformatierung richtet sich nach dem Standard-Gebietsschema der JVM, sofern es nicht überschrieben wird. In en-US erhält man 3.14; in de-DE erhält man 3,14; in fr-FR werden Tausender mit einem geschützten Leerzeichen gruppiert. Für benutzerorientierte Ausgaben ist das meist erwünscht. Für Datenformate — JSON, CSV, Protokolldateien, alles maschinenlesbare — ist es ein Desaster, das auf seinen Einsatz in Frankfurt wartet.

Für maschinenlesbare Ausgaben immer explizit ein Gebietsschema übergeben:

String json = String.format(Locale.ROOT, "{\"price\": %.2f}", 19.95);
// "{\"price\": 19.95}" — always, regardless of JVM locale

Locale.ROOT bedeutet „keine gebietsschemaspezifische Formatierung" — Punkt als Dezimaltrennzeichen, keine Gruppierung. Locale.US ist die andere übliche Wahl für denselben Zweck. Das Gefährliche ist, kein Gebietsschema zu übergeben und einfach anzunehmen.

Datum und Uhrzeit formatieren

%t ist eine Meta-Konvertierung: der folgende Buchstabe wählt das Feld aus. Dasselbe Date-, Calendar-, Long- (Millisekunden) oder java.time.temporal.TemporalAccessor-Argument kann auf viele Arten formatiert werden:

LocalDateTime now = LocalDateTime.of(2026, 5, 29, 14, 30, 15);
String.format("%tF",   now);          // "2026-05-29"  — ISO date
String.format("%tT",   now);          // "14:30:15"    — 24-hour time
String.format("%tA",   now);          // "Friday"      — locale-dependent
String.format("%1$tF %1$tT", now);    // "2026-05-29 14:30:15"

Für alles, was über schnelle Formatierung hinausgeht, ist die java.time.format.DateTimeFormatter-API flexibler und gebietsschemabewusster — aber %tF und ähnliche bleiben in Protokollzeilen nützlich.

Häufige Fallstricke

Falsche Konvertierung für den Typ. String.format("%d", 3.14) wirft zur Laufzeit eine IllegalFormatConversionException — %d erwartet ganzzahlig, %f erwartet Gleitkomma. Der Compiler kann das nicht prüfen.
Fehlende Argumente. Das Vergessen eines Platzhalterarguments wirft eine MissingFormatArgumentException.
Gebietsschemaabhängige Dezimaltrennung in Maschinenausgaben. Oben behandelt.
%s auf null. Ergibt "null". In Protokollen in Ordnung, in benutzerorientierter Ausgabe peinlich.
+ für formatierte Zahlen verwenden. "Price: " + 19.95 ergibt "Price: 19.95", aber "Price: " + 0.1 + 0.2 ergibt "Price: 0.10.2", nicht "Price: 0.3" — Konkatenation, keine Addition.

Ein ausgearbeitetes Beispiel

Ein kleiner Auftragsübersichts-Formatierer, der Breite, Präzision, Ausrichtung, Gruppierung, Gebietsschema und %t-Datumskonvertierung einsetzt. Die Ausgabe ist ein übersichtlicher zweispaltiger Bericht — die Art von Ding, die man sonst mit padLeft-Hilfsmethoden manuell aufbaut.

java— editable, runs on the server

import java.time.LocalDateTime;
import java.util.Locale;

public class FormattingDemo {
  public static void main(String[] args) {
    String customer = "Ada Lovelace";
    int orderId = 4217;
    double subtotal = 1234.5;
    double tax      = subtotal * 0.085;
    double total    = subtotal + tax;
    LocalDateTime placedAt = LocalDateTime.of(2026, 5, 29, 14, 30);

// Header — left-aligned, fixed width.
    String header = String.format("%-20s %s%n", "Order #" + orderId, "--------");
    System.out.print(header);

// Two-column layout: label left-padded, value right-padded with grouping.
    System.out.printf("%-12s %s%n",        "Customer:",  customer);
    System.out.printf("%-12s %tF %<tT%n",  "Placed:",     placedAt);
    System.out.printf("%-12s %,12.2f%n",   "Subtotal:",   subtotal);
    System.out.printf("%-12s %,12.2f%n",   "Tax (8.5%):", tax);
    System.out.printf("%-12s %,12.2f%n",   "Total:",      total);

System.out.println();

// Same total, machine-readable JSON line — locale-pinned so the
    // decimal separator is always a period, regardless of the JVM locale.
    String jsonLine = String.format(Locale.ROOT,
      "{\"order\": %d, \"total\": %.2f}", orderId, total);
    System.out.println(jsonLine);

// The instance form added in Java 15 — same result, reads naturally.
    String summary = "Order %d for %s totals $%,.2f".formatted(orderId, customer, total);
    System.out.println(summary);
  }
}

Zwei Dinge sind zu beachten: Das %<tT in der Zeile „Placed" verwendet das vorherige Argument wieder (< ist das Rückverweisflag), wodurch ein redundantes zweites placedAt vermieden wird. Und die JSON-Zeile verwendet Locale.ROOT — derselbe Code auf einer deutschen JVM gibt immer noch 1339.43 aus, nicht 1339,43, was genau das ist, was ein JSON-Parser erwartet.

Was kommt als Nächstes

Strings zu erstellen ist eine Hälfte der Aufgabe. Sie zu vergleichen — Gleichheit, Reihenfolge, Groß-/Kleinschreibung, der Unterschied zwischen == und equals — ist die andere Hälfte und eine häufige Quelle subtiler Fehler. Weiter zu Java-String-Vergleich.

Übungen

Übung

Sie möchten einen `double`-Gesamtbetrag als String mit Tausendertrennzeichen und genau zwei Dezimalstellen formatieren, und der Dezimalpunkt soll unabhängig vom Gebietsschema der JVM immer ein Punkt sein (damit ein JSON-Parser ihn verarbeiten kann). Welcher Aufruf ist korrekt?

`String.format(Locale.ROOT, "%,.2f", total)``String.format("%,.2f", total)``String.format("%.2,f", total)``total.toString().substring(0, 6)`