0Pricing
Java Academy · Lektion

Textblöcke und String.format

Schreiben Sie mehrzeilige Strings mit Textblöcken und formatieren Sie Daten mit String.format-Mustern.

Textblöcke und String.format ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Textblöcke und String.format

Textblöcke (Java 15+) ermöglichen mehrzeilige String-Literale ohne Escape-Sequenzen. Zusammen mit String.format und formatted() sorgen sie für eine übersichtliche und gut lesbare Ausgabe komplexer Strings.

Was sind Textblöcke?

Ein Textblock ist ein String-Literal, das in drei doppelte Anführungszeichen """ eingeschlossen ist. Er bewahrt Zeilenumbrüche und Einrückungen automatisch und macht Escape-Sequenzen bei mehrzeiligem Inhalt überflüssig.

// Traditional multi-line string
String old = "SELECT id, name, email\n" +
             "FROM users\n" +
             "WHERE active = true\n" +
             "ORDER BY name;";

// Text block (Java 15+) — much cleaner
String sql = """
    SELECT id, name, email
    FROM users
    WHERE active = true
    ORDER BY name;
    """;

System.out.println(sql);

Behandlung von Einrückungen

Textblöcke entfernen automatisch gemeinsame führende Leerzeichen. Die Position des schließenden """ steuert die Einrückung.

// Leading spaces up to the closing """ are stripped
String json = """
        {
            "name": "Alice",
            "role": "admin"
        }
        """;
// Output has no leading spaces (stripped by common indent)
System.out.println(json);
// {
//     "name": "Alice",
//     "role": "admin"
// }

Eingebettete Anführungszeichen

Textblöcke können doppelte Anführungszeichen ohne Escape-Sequenz enthalten, solange nicht drei aufeinanderfolgende Anführungszeichen vorkommen. Ein einzelnes " und "" sind unproblematisch.

String html = """
    <div class="container">
        <p class="title">Hello, World!</p>
        <a href="https://example.com">Click here</a>
    </div>
    """;
System.out.println(html);
// Note: no need to escape " inside the block

Textblöcke für JSON-Vorlagen

Textblöcke eignen sich besonders für JSON-, HTML-, XML- und SQL-Vorlagen in Tests oder Konfigurationen.

String request = """
    {
        "email": "alice@example.com",
        "password": "secret123",
        "plan": "PRO"
    }
    """;

// In tests: compare expected JSON
String expected = """
    {
      "status": "created",
      "id": 42
    }
    """;
// Perfect for MockMvc test assertions
System.out.println(request);

formatted() mit Textblöcken

Kombinieren Sie Textblöcke mit formatted() (Java 15+), um parametrisierte Vorlagen zu erstellen.

String name = "Alice";
long orderId = 1234L;
double total = 149.99;

String email = """
    Dear %s,

    Your order #%d has been confirmed.
    Total charged: $%.2f

    Thank you for shopping with us!
    """.formatted(name, orderId, total);

System.out.println(email);
// Dear Alice,
// Your order #1234 has been confirmed.
// Total charged: $149.99

Escape-Sequenzen in Textblöcken

Textblöcke unterstützen \n, \t sowie die in Java 14+ eingeführten Sequenzen \ (Zeilenfortsetzung) und \s (nachfolgende Leerzeichen beibehalten).

// \s forces a space (preserves trailing whitespace on line)
String padded = """
    line one  \s
    line two   \s
    """;

// \ (backslash at end of line) joins lines in source but keeps them as one
String poem = """
    Roses are red, \
    violets are blue.
    """;
System.out.println(poem); // Roses are red, violets are blue.

Referenz zu String.format

Wichtige Formatbezeichner für String.format:

  • %s – String
  • %d – Ganzzahl
  • %f – Gleitkommazahl
  • %.2f – 2 Nachkommastellen
  • %n – plattformabhängiger Zeilenumbruch
  • %x – hexadezimale Darstellung
  • %10d – rechtsbündig in 10 Zeichen
System.out.printf("%s | %d | %.2f | %X%n", "Item", 42, 9.99, 255);
// Item | 42 | 9.99 | FF

String formatted = String.format("%-20s %6.2f%n", "Mechanical Keyboard", 129.95);
System.out.print(formatted);
// Mechanical Keyboard 129.95

// Named format with text block
System.out.printf("""
    Order: %s
    Total: $%.2f
    Status: %s%n""", "ORD-001", 99.99, "SHIPPED");

Textblockmethoden stripIndent und translateEscapes

Zwei String-Methoden arbeiten mit Textblöcken: stripIndent() entfernt gemeinsame führende Leerzeichen, und translateEscapes() verarbeitet Escape-Sequenzen in einem String zur Laufzeit.

String raw = "  hello\\n  world";
System.out.println(raw);                    // hello\n  world
System.out.println(raw.translateEscapes()); // hello (newline) world

// stripIndent removes common leading whitespace
String indented = "    line 1\n    line 2\n    line 3";
System.out.println(indented.stripIndent()); // line 1\nline 2\nline 3

Praxisbeispiel: HTML-E-Mail-Vorlage

Erstellen einer parametrisierten HTML-E-Mail-Vorlage mit einem Textblock.

static String buildWelcomeEmail(String name, String activationLink) {
    return """
        <!DOCTYPE html>
        <html>
          <body>
            <h1>Welcome, %s!</h1>
            <p>Click the link below to activate your account:</p>
            <a href="%s">Activate Account</a>
          </body>
        </html>
        """.formatted(name, activationLink);
}

System.out.println(buildWelcomeEmail("Alice",
    "https://app.example.com/activate?token=abc123"));

Textblöcke im Vergleich zu String.join

Für Listen von Elementen ist String.join oder Collectors.joining flexibler als ein Textblock. Verwenden Sie Textblöcke für feste mehrzeilige Inhalte und join für dynamische Listen.

import java.util.*;
import java.util.stream.*;

List<String> features = List.of("Unlimited storage", "Priority support", "AI assistant");

// Dynamic list: join
String bullet = features.stream()
    .map(f -> "  • " + f)
    .collect(Collectors.joining("\n"));
System.out.println(bullet);
// • Unlimited storage
// • Priority support
// • AI assistant

// Fixed template: text block + formatted
String plan = """
    PRO Plan — $29/month
    Features:
    %s
    """.formatted(bullet);
System.out.println(plan);

Kurzer Test

Was steuert die Position des schließenden """ in einem Textblock?

Zusammenfassung: Textblöcke und String.format

Wichtige Erkenntnisse:

  • Textblöcke (Java 15+) verwenden drei Anführungszeichen und bewahren die mehrzeilige Struktur ohne Escape-Sequenzen
  • Gemeinsame führende Leerzeichen werden automatisch entfernt, basierend auf der Position des schließenden \"\"\"
  • Doppelte Anführungszeichen innerhalb von Textblöcken müssen nicht maskiert werden
  • Verwenden Sie .formatted() auf einem Textblock für parametrisierte Vorlagen
  • String.format-Bezeichner: %s, %d, %.2f, %n, %x sowie Breiten- und Ausrichtungsflags
  • Verwenden Sie \s am Zeilenende, um nachfolgende Leerzeichen beizubehalten, und \ am Zeilenende, um Zeilen zu verbinden

Häufig gestellte Fragen

Ist die Lektion „Textblöcke und String.format“ kostenlos?

Ja — der vollständige Text von „Textblöcke und String.format“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Textblöcke und String.format“?

Schreiben Sie mehrzeilige Strings mit Textblöcken und formatieren Sie Daten mit String.format-Mustern. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Textblöcke und String.format“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Unveränderlichkeit von String und der String-Pool
  2. StringBuilder für effiziente Verkettung
  3. Textblöcke und String.format
  4. Reguläre Ausdrücke mit Pattern und Matcher
← Zurück zu Java Academy