Blocs de texte Java : littéraux chaînes multilignes

Un bloc de texte est un littéral chaîne multiligne qui vous évite la lourdeur des sauts de ligne échappés et des concaténations. Introduit en aperçu dans Java 13 et rendu permanent dans Java 15, il vous permet de coller du HTML, du JSON, du SQL ou tout bloc de texte formaté directement dans votre source, lisible tel quel.

Avant les blocs de texte, quelques lignes de balises imbriquées signifiaient un mur d'échappements \n et d'opérateurs +. Un bloc de texte s'ouvre avec trois guillemets doubles (""") suivis d'un saut de ligne, et tout ce qui précède le """ fermant devient la chaîne — la gestion des espaces de début étant traitée intelligemment.

La syntaxe avec guillemets triples

Un bloc de texte commence par """ et un terminateur de ligne. Le contenu commence à la ligne suivante ; le délimiteur d'ouverture ne peut pas partager une ligne avec du texte. Le bloc se termine par un autre """.

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

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

Avertissement

L'erreur de compilation la plus courante est d'écrire du contenu sur la ligne d'ouverture, par exemple String s = """{. Le """ d'ouverture doit être immédiatement suivi d'un terminateur de ligne — seul le """ fermant peut partager sa ligne avec du texte.

Les deux produisent des chaînes presque identiques, mais le bloc de texte est lisible d'un coup d'œil et les guillemets doubles intégrés n'ont pas besoin d'être échappés. Un bloc de texte est une String comme les autres — il n'existe pas de type séparé — donc toutes les méthodes String s'appliquent, et un bloc de texte reste immuable une fois créé.

Espaces accidentels et essentiels

Le compilateur distingue les espaces accidentels (indentation ajoutée uniquement pour garder le source lisible) des espaces essentiels (indentation que vous souhaitez réellement dans la valeur). Il trouve la ligne avec le moins d'espaces de début — y compris la ligne du """ fermant — et supprime cette quantité commune de chaque ligne.

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"

Déplacer le délimiteur fermant modifie la quantité supprimée. Placer """ tout à gauche ne supprime aucune indentation ; le placer sous la ligne la plus profonde les supprime toutes. Vous avez ainsi un contrôle précis sans compter les espaces à la main.

Échappements et saut de ligne final

Les blocs de texte supportent les séquences d'échappement habituelles, plus deux qui n'existent que pour eux :

Échappement	Effet
`\n`, `\t`, `\"`	Échappements standard, toujours valides
`\` (en fin de ligne)	Continuation de ligne — supprime le saut de ligne qui suivrait
`\s`	Un espace unique qui n'est jamais supprimé comme espace accidentel

Un bloc de texte dont le contenu se termine sur sa propre ligne inclut un saut de ligne final ; placer le """ fermant sur la même ligne que le dernier texte l'omet.

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

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

Cas d'utilisation courants

Les blocs de texte excellent partout où du texte formaté multiligne apparaît dans le code :

// 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"]
    }
    """;

Parce que le texte reflète sa forme finale, copier-coller un extrait d'un fichier .sql ou .json fonctionne directement, et les relecteurs peuvent repérer immédiatement les erreurs de formatage.

Les blocs de texte en action

L'exemple ci-dessous illustre toutes les fonctionnalités : suppression des espaces accidentels, formatted() pour les espaces réservés, le flux lines(), les échappements \s et \ en fin de ligne, l'indentation contrôlée par le délimiteur, et les guillemets doubles intégrés sans échappement. Lisez les commentaires — chaque ligne correspond à une règle ci-dessus.

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);
    }
}

Ce qu'il faut retenir de l'exécution :

Le bloc brut affiche <html> aligné à la marge gauche même s'il était indenté dans le source, car l'espace accidentel commun a été supprimé relativement au """ fermant.
formatted("World") substitue l'espace réservé %s, prouvant qu'un bloc de texte est une String ordinaire que vous pouvez passer aux méthodes de formatage.
Line count: 5 provient de html.lines() parcourant les cinq lignes de contenu ; le saut de ligne final ajouté par le """ fermant sur sa propre ligne termine la dernière ligne plutôt que de créer une sixième vide.
Has trailing space: true montre que \s a forcé un espace à survivre que le compilateur aurait autrement supprimé comme accidentel.
Continuation: Roses are red, violets are blue. prouve qu'un \ en fin de ligne a joint les deux lignes source en une, et {"name": "Ada", "active": true} s'est affiché sans un seul guillemet échappé.

Exercice pratique

Pratique

Dans un bloc de texte Java, qu'est-ce qui détermine la quantité d'espaces de début supprimée de chaque ligne ?

La ligne avec le moins d'indentation, y compris la ligne du triple-guillemet fermantToujours exactement quatre espaces, quelle que soit l'indentation du blocL'indentation du délimiteur triple-guillemet d'ouvertureRien n'est jamais supprimé ; les blocs de texte préservent tous les espaces littéralement