Java Academy · Leçon

StringBuilder ou StringBuffer

Compromis liés à la sécurité des threads

StringBuilder ou StringBuffer est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Deux classes modifiables

Java possède deux classes de chaînes modifiables : StringBuilder et StringBuffer. Leurs API sont presque identiques, mais elles diffèrent sur un point essentiel : la sécurité des fils d’exécution.

Même API

Les deux classes proposent append, insert, delete, reverse et les autres méthodes. Le code utilisant l’une peut généralement passer à l’autre en changeant uniquement le nom du type.

public class Main {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello").append(", ").append("World");
        System.out.println(sb);
    }
}

StringBuffer est synchronisé

Les méthodes de StringBuffer sont synchronisées, ce qui signifie que plusieurs fils d’exécution peuvent modifier la même instance en toute sécurité. Cette sécurité a un léger coût en performances.

public class Main {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("thread-safe");
        buffer.append("!");
        System.out.println(buffer);
    }
}

StringBuilder n’est pas synchronisé

StringBuilder évite la synchronisation, ce qui le rend plus rapide. En contrepartie, il n’est pas sûr de partager une même instance entre plusieurs fils d’exécution sans coordination externe.

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("fast");
        builder.append("!");
        System.out.println(builder);
    }
}

Quand utiliser StringBuilder

Utilisez StringBuilder dans le cas courant : pour construire des chaînes à l’intérieur d’une seule méthode ou d’un seul fil d’exécution. C’est le choix par défaut pour presque tout le code courant.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            sb.append("#");
        }
        System.out.println(sb);
    }
}

Quand utiliser StringBuffer

Choisissez StringBuffer uniquement lorsque la même instance de l’outil de construction est réellement partagée et modifiée par plusieurs fils d’exécution. En pratique, ce cas est rare.

public class Main {
    public static void main(String[] args) {
        StringBuffer shared = new StringBuffer("log: ");
        shared.append("event A; ");
        shared.append("event B");
        System.out.println(shared);
    }
}

Les variables locales ne sont pas partagées

Un générateur déclaré et utilisé uniquement à l’intérieur d’une méthode n’est jamais visible par les autres fils d’exécution ; StringBuilder est donc toujours approprié dans ce contexte. L’absence de synchronisation ne peut pas poser de problème.

public class Main {
    static String build() {
        StringBuilder sb = new StringBuilder();
        sb.append("local only");
        return sb.toString();
    }
    public static void main(String[] args) {
        System.out.println(build());
    }
}

Écart de performances

Le coût de synchronisation de StringBuffer le rend plus lent lors d’une utilisation avec un seul fil d’exécution. Pour les boucles intensives, StringBuilder offre de meilleures performances.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append('x');
        }
        System.out.println("Built length: " + sb.length());
    }
}

Repère historique

StringBuffer est apparu en premier, dans les premières versions de Java. StringBuilder a été ajouté dans Java 5 comme solution de remplacement plus rapide et non synchronisée pour le cas courant d’une utilisation avec un seul fil d’exécution.

Faire le bon choix

Par défaut, utilisez StringBuilder. Ne passez à StringBuffer que si vous pouvez prouver qu’une même instance est partagée entre plusieurs fils d’exécution. Sinon, vous payez le coût d’une sécurité dont vous n’avez pas besoin.

public class Main {
    public static void main(String[] args) {
        StringBuilder result = new StringBuilder();
        result.append("Use StringBuilder ").append("by default");
        System.out.println(result);
    }
}

Les deux convertissent en String

Les deux classes produisent une String immuable au moyen de toString(). Le choix entre elles ne concerne que la construction, et non le résultat final.

public class Main {
    public static void main(String[] args) {
        String a = new StringBuilder("one").toString();
        String b = new StringBuffer("two").toString();
        System.out.println(a + " " + b);
    }
}

Vérification rapide

Quelle est la principale différence entre StringBuilder et StringBuffer ?

Récapitulatif

Vous avez appris quels compromis faire :

Les deux possèdent des interfaces presque identiques
StringBuffer est synchronisé (sûr pour les fils d’exécution, mais plus lent)
StringBuilder est non synchronisé (plus rapide)
Utilisez par défaut StringBuilder pour une construction avec un seul fil d’exécution
Utilisez StringBuffer uniquement pour les instances réellement partagées

Questions Fréquemment Posées

La leçon « StringBuilder ou StringBuffer » est-elle gratuite ?

Oui — le texte complet de « StringBuilder ou StringBuffer » 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 ou StringBuffer » ?

Compromis liés à la sécurité des threads 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 4 sur 4.

Combien de temps prend la leçon « StringBuilder ou StringBuffer » ?

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

Pourquoi les chaînes sont immuables
Construire des chaînes avec StringBuilder
Méthodes de StringBuilder
StringBuilder ou StringBuffer

← Retour à Java Academy