Java Text Blocks: Mehrzeilige String-Literale

Ein Text Block ist ein mehrzeiliges String-Literal, das Sie von escaped Zeilenumbrüchen und Verkettungen befreit. Eingeführt als Preview in Java 13 und dauerhaft in Java 15, ermöglicht es Ihnen, HTML, JSON, SQL oder beliebige formatierte Texte direkt in Ihren Quellcode einzufügen, sodass er wie das Original aussieht.

Vor Text Blocks bedeuteten wenige Zeilen eingebetteter Markup eine Wand aus \n-Escapes und +-Operatoren. Ein Text Block öffnet mit drei doppelten Anführungszeichen (""") gefolgt von einem Zeilenumbruch, und alles bis zum schließenden """ wird zum String — mit führendem Leerzeichen, das intelligent behandelt wird.

Die Triple-Quote-Syntax

Ein Text Block beginnt mit """ und einem Zeilentrenner. Der Inhalt beginnt auf der nächsten Zeile; das öffnende Trennzeichen kann keine Zeile mit Text teilen. Der Block endet mit einem weiteren """.

// Old way: escapes and concatenation
String json = "{\n" +
              "  \"name\": \"Ada\"\n" +
              "}";

// Text block: paste it as-is
String block = """
    {
      "name": "Ada"
    }
    """;

Warnung

Der häufigste Kompilierfehler ist, Inhalt auf der Eröffnungszeile zu schreiben, z. B. String s = """{. Das öffnende """ muss sofort von einem Zeilentrenner gefolgt werden — nur das schließende """ darf seine Zeile mit Text teilen.

Die beiden erzeugen nahezu identische Strings, aber der Text Block ist auf einen Blick lesbar, und eingebettete doppelte Anführungszeichen müssen nicht escaped werden. Ein Text Block ist ein String wie jeder andere — es gibt keinen separaten Typ — daher funktioniert jede String-Methode darauf, und ein Text Block ist nach der Erstellung weiterhin unveränderlich.

Zufälliges vs. wesentliches Leerzeichen

Der Compiler unterscheidet zufälliges Leerzeichen (Einrückung, die nur hinzugefügt wird, um den Quellcode ordentlich zu halten) von wesentlichem Leerzeichen (Einrückung, die tatsächlich im Wert vorhanden sein soll). Er findet die Zeile mit dem geringsten führenden Leerzeichen — einschließlich der schließenden """-Zeile — und entfernt diesen gemeinsamen Betrag von jeder Zeile.

String html = """
        <p>Hi</p>
    """;
// The closing """ is indented 4 spaces, the <p> 8 spaces.
// Common minimum is 4, so the result keeps 4 leading spaces: "    <p>Hi</p>\n"

Das Verschieben des schließenden Trennzeichens ändert den Abzugsbetrag. """ ganz links zu setzen entfernt keine Einrückung; es unter die tiefste Zeile zu setzen entfernt alles davon. So haben Sie präzise Kontrolle, ohne Leerzeichen manuell zu zählen.

Escapes und der abschließende Zeilenumbruch

Text Blocks unterstützen die üblichen Escape-Sequenzen sowie zwei, die nur für sie existieren:

Escape	Effekt
`\n`, `\t`, `\"`	Standard-Escapes, weiterhin gültig
`\` (Zeilenende)	Zeilenfortsetzung — unterdrückt den darauf folgenden Zeilenumbruch
`\s`	Ein einzelnes Leerzeichen, das nie als zufälliges Leerzeichen entfernt wird

Ein Text Block, dessen Inhalt auf einer eigenen Zeile endet, enthält einen abschließenden Zeilenumbruch; das schließende """ auf derselben Zeile wie den letzten Text zu platzieren lässt ihn weg.

String withNewline = """
    last line
    """;          // ends with "\n"

String noNewline = """
    last line""";  // no trailing newline

Häufige Anwendungsfälle

Text Blocks glänzen überall dort, wo formatierter, mehrzeiliger Text im Code erscheint:

// SQL kept readable instead of one long escaped string
String query = """
    SELECT id, name, price
    FROM products
    WHERE price < ?
    ORDER BY name
    """;

// JSON payload with quotes that need no escaping
String payload = """
    {
      "user": "ada",
      "roles": ["admin", "editor"]
    }
    """;

Da der Text seine endgültige Form widerspiegelt, funktioniert das Einfügen eines Ausschnitts aus einer .sql- oder .json-Datei einfach, und Reviewer können Formatierungsfehler sofort erkennen.

Text Blocks in Aktion

Das folgende Beispiel verwendet jede Funktion: Entfernung von zufälligem Leerzeichen, formatted() für Platzhalter, den lines()-Stream, die Escapes \s und Zeilenende-\, durch Trennzeichen gesteuerte Einrückung und nicht-escaped eingebettete Anführungszeichen. Lesen Sie die Kommentare — jede Zeile entspricht einer Regel oben.

java— editable, runs on the server

public class TextBlockDemo {
    public static void main(String[] args) {
        // A text block: opening """ must be followed by a line terminator.
        String html = """
            <html>
                <body>
                    <p>Hello, %s!</p>
                </body>
            </html>
            """;

// Incidental indentation is stripped relative to the closing """.
        System.out.println("--- raw text block ---");
        System.out.print(html);

// Text blocks are just String instances; all String methods apply.
        String formatted = html.formatted("World");
        System.out.println("--- formatted ---");
        System.out.print(formatted);

// The line count proves the trailing newline from the closing line.
        long lines = html.lines().count();
        System.out.println("Line count: " + lines);

// \ at end of line suppresses the newline (line continuation).
        String oneLine = """
            Roses are red, \
            violets are blue.""";
        System.out.println("Continuation: " + oneLine);

// \s is a space escape that preserves trailing whitespace.
        String padded = """
            ends here:\s
            next line""";
        System.out.println("Has trailing space: "
            + (padded.split("\n")[0].endsWith(" ")));

// Closing delimiter position controls how much indent is removed.
        String indented = """
                kept
              base""";
        System.out.println("--- indentation control ---");
        System.out.println(indented);

// No special escaping needed for embedded double quotes.
        String json = """
            {"name": "Ada", "active": true}""";
        System.out.println("JSON: " + json);
    }
}

Was die Ausführung zeigt:

Der rohe Block gibt <html> bündig am linken Rand aus, obwohl er im Quellcode eingerückt war, weil das gemeinsame zufällige Leerzeichen relativ zum schließenden """ entfernt wurde.
formatted("World") ersetzt den %s-Platzhalter und beweist, dass ein Text Block ein gewöhnlicher String ist, den Sie an Formatierungsmethoden übergeben können.
Line count: 5 kommt von html.lines(), das die fünf Inhaltszeilen streamt; der abschließende Zeilenumbruch, der durch das schließende """ auf seiner eigenen Zeile hinzugefügt wird, beendet die letzte Zeile, anstatt eine leere sechste zu erstellen.
Has trailing space: true zeigt, dass \s ein Leerzeichen erzwungen hat, das der Compiler sonst als zufällig abgeschnitten hätte.
Continuation: Roses are red, violets are blue. beweist, dass ein \ am Zeilenende die beiden Quellzeilen zu einer verbunden hat, und {"name": "Ada", "active": true} wurde ohne ein einziges escaped Anführungszeichen ausgegeben.

Übungsaufgaben

Übung

Was bestimmt in einem Java Text Block, wie viel führendes Leerzeichen von jeder Zeile entfernt wird?

Die Zeile mit der geringsten Einrückung, einschließlich der schließenden Triple-Quote-ZeileImmer genau vier Leerzeichen, unabhängig von der Einrückung des BlocksDie Einrückung des öffnenden Triple-Quote-TrennzeichensEs wird nie etwas entfernt; Text Blocks behalten alle Leerzeichen buchstäblich bei