Java Academy · Leçon

StringBuilder pour une concaténation efficace

Utilisez StringBuilder pour construire efficacement des chaînes dans les boucles et les formats complexes.

StringBuilder pour une concaténation efficace est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

StringBuilder pour une concaténation efficace

StringBuilder est une alternative mutable à String pour construire du texte progressivement. Il évite de créer de nombreux objets String intermédiaires.

StringBuilder contre concaténation de String

Lorsque vous concaténez de nombreuses chaînes, en particulier dans des boucles, StringBuilder est nettement plus rapide, car il modifie un tampon de caractères interne au lieu de créer de nouveaux objets.

// Inefficient: creates a new String every iteration
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i + ","; // 1000 new String objects!
}

// Efficient: StringBuilder uses a resizable char buffer
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(',');
}
String efficient = sb.toString(); // one final String created

API de StringBuilder

Méthodes principales : append, insert, delete, replace, reverse, toString, longueur, charAt, setCharAt.

StringBuilder sb = new StringBuilder("Hello");

sb.append(", World");     // Hello, World
sb.insert(5, "!");        // Hello!, World
sb.delete(5, 6);           // Hello, World
sb.replace(7, 12, "Java"); // Hello, Java
sb.reverse();               // avaJ ,olleH
sb.reverse();               // Hello, Java

System.out.println(sb);         // Hello, Java
System.out.println(sb.length()); // 11
System.out.println(sb.charAt(0)); // H

Chaînage des appels à append

Toutes les méthodes append et les autres méthodes de modification renvoient this, ce qui permet un chaînage fluide.

StringBuilder html = new StringBuilder()
    .append("<div class=\"card\">")
    .append("<h2>").append("Product Title").append("</h2>")
    .append("<p>Price: $").append(String.format("%.2f", 29.99)).append("</p>")
    .append("<button>Add to Cart</button>")
    .append("</div>");

System.out.println(html.toString());

Capacité initiale

Initialisez StringBuilder avec une capacité correspondant à la taille attendue afin d'éviter le redimensionnement du tableau interne et d'améliorer les performances pour les grandes chaînes.

// Default capacity: 16 chars
StringBuilder small = new StringBuilder();

// Pre-sized: 10 items * ~50 chars each
StringBuilder report = new StringBuilder(500);

for (int i = 1; i <= 10; i++) {
    report.append(String.format("%-3d. Record %04d: processed OK%n", i, i));
}

System.out.println(report.toString().substring(0, 30));
// "  1. Record 0001: processed OK"

deleteCharAt et suppressions ciblées

deleteCharAt supprime un seul caractère. delete(start, end) supprime une plage. Ces opérations sont en O(n) en raison du décalage des éléments du tableau.

StringBuilder sb = new StringBuilder("Hello, World!");

sb.deleteCharAt(5);     // removes comma: "Hello World!"
sb.delete(5, 6);         // removes space: "HelloWorld!"

System.out.println(sb); // HelloWorld!

// Replace to fix a typo
StringBuilder typo = new StringBuilder("Helo, Java!");
typo.replace(typo.indexOf("Helo"), typo.indexOf("Helo") + 4, "Hello");
System.out.println(typo); // Hello, Java!

Construction de CSV

Schéma pratique : construire une ligne CSV avec StringBuilder en gérant correctement les séparateurs.

import java.util.List;

static String toCsv(List<String> values) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < values.size(); i++) {
        if (i > 0) sb.append(',');
        sb.append(escapeCsv(values.get(i)));
    }
    return sb.toString();
}

static String escapeCsv(String s) {
    if (s.contains(",") || s.contains("\""))
        return "\"" + s.replace("\"", "\"\"") + "\"";
    return s;
}

System.out.println(toCsv(List.of("Alice", "Smith, Jr.", "30")));
// Alice,"Smith, Jr.",30

StringJoiner pour une sortie séparée par délimiteur

StringJoiner simplifie l'assemblage d'éléments avec un délimiteur, un préfixe et un suffixe facultatifs : aucune gestion manuelle des séparateurs n'est nécessaire.

import java.util.StringJoiner;

StringJoiner sj = new StringJoiner(", ", "[", "]");
sj.add("Alice");
sj.add("Bob");
sj.add("Charlie");
System.out.println(sj.toString()); // [Alice, Bob, Charlie]

// Equivalent with String.join
String joined = String.join(", ", "Alice", "Bob", "Charlie");
System.out.println(joined); // Alice, Bob, Charlie

// Streams: collect with joining collector
import java.util.stream.*;
List.of("a", "b", "c").stream()
    .collect(Collectors.joining(", ", "(", ")"));
// (a, b, c)

StringBuilder contre StringBuffer

StringBuffer est la version synchronisée et sûre vis-à-vis des threads de StringBuilder. Elle est plus lente en raison des verrouillages. Utilisez StringBuilder dans les contextes à thread unique, qui représentent 99 % des cas.

// StringBuffer: thread-safe but slower (synchronized methods)
StringBuffer buf = new StringBuffer();
buf.append("Thread-safe");
buf.append(" but slow");

// StringBuilder: not thread-safe but faster
StringBuilder sb = new StringBuilder();
sb.append("Fast");
sb.append(" single-threaded");

// When to use StringBuffer:
// - Multiple threads write to the same buffer
// - Almost always a design smell — redesign to avoid sharing

Inversion et vérification de palindrome

La méthode reverse() intégrée à StringBuilder rend la vérification des palindromes élégante.

static boolean isPalindrome(String s) {
    String cleaned = s.toLowerCase()
        .replaceAll("[^a-z0-9]", ""); // remove non-alphanumeric
    String reversed = new StringBuilder(cleaned).reverse().toString();
    return cleaned.equals(reversed);
}

System.out.println(isPalindrome("A man, a plan, a canal: Panama")); // true
System.out.println(isPalindrome("race a car"));                      // false
System.out.println(isPalindrome("Was it a car or a cat I saw?"));    // true

Cas concret : générateur de requêtes SQL

Construire une requête SQL dynamique avec StringBuilder, en ajoutant conditionnellement les clauses de la requête.

static String buildQuery(String category, Double minPrice, Double maxPrice) {
    StringBuilder sql = new StringBuilder("SELECT * FROM products WHERE 1=1");
    if (category != null)
        sql.append(" AND category = '" + category + "'");
    if (minPrice != null)
        sql.append(" AND price >= ").append(minPrice);
    if (maxPrice != null)
        sql.append(" AND price <= ").append(maxPrice);
    sql.append(" ORDER BY name");
    return sql.toString();
}

System.out.println(buildQuery("Electronics", 50.0, null));
// SELECT * FROM products WHERE 1=1 AND category = 'Electronics' AND price >= 50.0 ORDER BY name

Vérification rapide

Pourquoi la concaténation de chaînes avec + est-elle inefficace dans les boucles ?

Récapitulatif : StringBuilder pour une concaténation efficace

Points essentiels :

StringBuilder est mutable : append, insert et delete modifient un tampon interne
Utilisez StringBuilder dans les boucles pour éviter la création de chaînes en O(n²)
Toutes les méthodes de modification renvoient l'objet courant, ce qui permet un chaînage fluide
Initialisez StringBuilder avec la capacité attendue pour réduire les redimensionnements internes
StringJoiner et String.join sont pratiques pour produire une sortie séparée par délimiteur
StringBuffer est l'alternative synchronisée, donc sûre vis-à-vis des threads, mais plus lente

Questions Fréquemment Posées

La leçon « StringBuilder pour une concaténation efficace » est-elle gratuite ?

Oui — le texte complet de « StringBuilder pour une concaténation efficace » 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 « StringBuilder pour une concaténation efficace » ?

Utilisez StringBuilder pour construire efficacement des chaînes dans les boucles et les formats complexes. 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 2 sur 4.

Combien de temps prend la leçon « StringBuilder pour une concaténation efficace » ?

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

Immutabilité des chaînes et pool de chaînes
StringBuilder pour une concaténation efficace
Blocs de texte et String.format
Expressions régulières avec Pattern et Matcher

← Retour à Java Academy