0Pricing
Java Academy · Leçon

Blocs de texte et String.format

Écrivez des chaînes multilignes avec les blocs de texte et formatez les données avec les modèles String.format.

Blocs de texte et String.format est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Blocs de texte et String.format

Les blocs de texte (Java 15 et versions ultérieures) permettent d'écrire des littéraux String multilignes sans échappement. Associés à String.format et formatted(), ils rendent la production de textes complexes claire et lisible.

Que sont les blocs de texte ?

Un bloc de texte est un littéral String entouré de triples guillemets doubles """. Il conserve automatiquement les retours à la ligne et l'indentation, ce qui élimine les séquences d'échappement pour le contenu multiligne.

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

Gestion de l'indentation

Les blocs de texte suppriment automatiquement les espaces blancs communs en début de ligne. La position du """ fermant contrôle l'indentation.

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

Guillemets intégrés

Les blocs de texte peuvent contenir des guillemets doubles sans échappement, tant que trois guillemets consécutifs n'apparaissent pas. Un seul " ou deux "" guillemets conviennent.

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

Blocs de texte pour les modèles JSON

Les blocs de texte sont particulièrement adaptés aux modèles JSON, HTML, XML et SQL utilisés dans les tests ou la configuration.

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() avec des blocs de texte

Combinez les blocs de texte avec formatted() (Java 15 et versions ultérieures) pour créer des modèles paramétrés.

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

Séquences d'échappement dans les blocs de texte

Les blocs de texte prennent en charge \n, \t, ainsi que \ de Java 14 et versions ultérieures (continuation de ligne) et \s (conservation des espaces blancs en fin de ligne).

// \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.

Référence de String.format

Principaux spécificateurs de format pour String.format :

  • %s — String
  • %d — entier
  • %f — nombre à virgule flottante
  • %.2f — 2 décimales
  • %n — retour à la ligne de la plateforme
  • %x — hexadécimal
  • %10d — alignement à droite sur 10 caractères
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");

Blocs de texte : stripIndent et translateEscapes

Deux méthodes de String fonctionnent avec les blocs de texte : stripIndent() supprime les espaces blancs communs en début de ligne, tandis que translateEscapes() traite les séquences d'échappement dans une chaîne au moment de l'exécution.

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

Cas pratique : modèle d'e-mail HTML

Construire un modèle d'e-mail HTML paramétré avec un bloc de texte.

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

Blocs de texte contre String.join

Pour les listes d'éléments, String.join ou Collectors.joining est plus flexible qu'un bloc de texte. Utilisez les blocs de texte pour un contenu multiligne fixe et join pour les listes dynamiques.

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

Vérification rapide

Que contrôle la position du """ fermant dans un bloc de texte ?

Récapitulatif : blocs de texte et String.format

Points essentiels :

  • Les blocs de texte (Java 15 et versions ultérieures) utilisent des triples guillemets et préservent la structure multiligne sans échappement
  • Les espaces blancs communs en début de ligne sont automatiquement supprimés selon la position du \"\"\" fermant
  • Les guillemets doubles à l'intérieur des blocs de texte n'ont pas besoin d'être échappés
  • Utilisez .formatted() sur un bloc de texte pour créer des modèles paramétrés
  • Spécificateurs de String.format : %s, %d, %.2f, %n, %x, indicateurs de largeur et d'alignement
  • Utilisez \s en fin de ligne pour conserver les espaces finaux ; utilisez \ en fin de ligne pour joindre les lignes

Questions Fréquemment Posées

La leçon « Blocs de texte et String.format » est-elle gratuite ?

Oui — le texte complet de « Blocs de texte et String.format » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Blocs de texte et String.format » ?

Écrivez des chaînes multilignes avec les blocs de texte et formatez les données avec les modèles String.format. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Blocs de texte et String.format » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Immutabilité des chaînes et pool de chaînes
  2. StringBuilder pour une concaténation efficace
  3. Blocs de texte et String.format
  4. Expressions régulières avec Pattern et Matcher
← Retour à Java Academy