StringBuffer et StringBuilder en Java

StringBuffer et StringBuilder en Java

  Prérequis

Maîtriser la classe String et son immuabilité. Comprendre les notions d'objet et de méthode en Java. Avoir des bases sur la notion de thread et de synchronisation (pour distinguer StringBuffer de StringBuilder).

  Objectifs

Comprendre pourquoi et quand utiliser StringBuffer et StringBuilder à la place de String. Maîtriser les méthodes essentielles de modification de chaînes : append, insert, replace, delete, reverse. Savoir choisir entre les trois classes selon le contexte.

1. Rappel — La limite de String

String resultat = "";
for (int i = 0; i < 10000; i++) {
    resultat += i;
}

2. StringBuffer vs StringBuilder vs String

3. La classe StringBuffer

3.1 Constructeurs

  Complément — Capacité vs Longueur

La longueur (length()) est le nombre de caractères actuellement stockés. La capacité (capacity()) est la taille du tampon interne alloué. La capacité initiale d'un StringBuffer(String s) est s.length() + 16. Quand la capacité est dépassée, Java la double automatiquement.

3.2 Méthodes principales

  Exemple 1 — Opérations sur StringBuffer

public class TestStringBuffer {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("Developpement Informatique");

        System.out.println("Longueur : " + s.length());
        System.out.println("Capacité : " + s.capacity());

        s.append(".com");
        System.out.println("Après append     : " + s);

        s.insert(13, "-");
        System.out.println("Après insert     : " + s);

        s.reverse();
        System.out.println("Après reverse    : " + s);

        s.delete(0, 5);
        System.out.println("Après delete(0,5): " + s);

        s.deleteCharAt(7);
        System.out.println("Après deleteCharAt(7): " + s);

        s.replace(0, 5, "Meknes");
        System.out.println("Après replace    : " + s);
    }
}

Longueur : 26
Capacité : 42
Après append     : Developpement Informatique.com
Après insert     : Developpement- Informatique.com
Après reverse    : moc.euqitamrofnI -tnemeppoleveD
Après delete(0,5): uqitamrofnI -tnemeppoleveD
Après deleteCharAt(7): uqitamrfnI -tnemeppoleveD
Après replace    : MeknesmrfnI -tnemeppoleveD

3.3 Chaînage de méthodes

Chaque méthode modificatrice de StringBuffer retourne l'objet lui-même. Cela permet de chaîner les appels sur une même ligne, rendant le code plus concis.

StringBuffer sb = new StringBuffer();

sb.append("Bonjour")
  .append(", ")
  .append("Java")
  .append(" !")
  .insert(8, "beau ");

System.out.println(sb);

Bonjour, beau Java !

3.4 Faits importants sur StringBuffer

4. La classe StringBuilder

StringBuilder sb = new StringBuilder();
StringBuilder sb = new StringBuilder("texte initial");
StringBuilder sb = new StringBuilder(256);

  Exemple 2 — StringBuilder pour concaténation performante

public class TestStringBuilder {
    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();

        for (int i = 1; i <= 5; i++) {
            sb.append("item").append(i);
            if (i < 5) sb.append(", ");
        }
        System.out.println(sb);

        sb.insert(0, "[").append("]");
        System.out.println(sb);

        sb.delete(7, 13);
        System.out.println(sb);

        System.out.println("Longueur : " + sb.length());

        String resultat = sb.toString();
        System.out.println("Converti en String : " + resultat);
    }
}

item1, item2, item3, item4, item5
[item1, item2, item3, item4, item5]
[item1, item3, item4, item5]
Longueur : 28
Converti en String : [item1, item3, item4, item5]

4.1 StringBuilder et les boucles — comparaison de performance

  Application — Mesure du temps de concaténation

int N = 50_000;

long debut = System.currentTimeMillis();
String s = "";
for (int i = 0; i < N; i++) {
    s += i;
}
long fin = System.currentTimeMillis();
System.out.println("String    : " + (fin - debut) + " ms");

debut = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < N; i++) {
    sb.append(i);
}
fin = System.currentTimeMillis();
System.out.println("StringBuilder : " + (fin - debut) + " ms");

String        : ~1200 ms
StringBuilder :    ~2 ms

5. Méthodes communes — Tableau récapitulatif

6. Exercice

Après appends  : Java est un langage
Après insert   : Java est un beau langage
Après replace  : Python est un beau langage
Après append ! : Python est un beau langage !
Longueur : 27
Capacité : 34
Contient "beau" : true

public class ExerciceStringBuilder {
    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();

        sb.append("Java")
          .append(" est")
          .append(" un")
          .append(" langage");
        System.out.println("Après appends  : " + sb);

        int posLangage = sb.indexOf(" langage");
        sb.insert(posLangage, " beau");
        System.out.println("Après insert   : " + sb);

        int posJava = sb.indexOf("Java");
        sb.replace(posJava, posJava + 4, "Python");
        System.out.println("Après replace  : " + sb);

        sb.append(" !");
        System.out.println("Après append ! : " + sb);

        System.out.println("Longueur : " + sb.length());
        System.out.println("Capacité : " + sb.capacity());

        String resultat = sb.toString();
        System.out.println("Contient \"beau\" : " + resultat.contains("beau"));
    }
}

Après appends  : Java est un langage
Après insert   : Java est un beau langage
Après replace  : Python est un beau langage
Après append ! : Python est un beau langage !
Longueur : 27
Capacité : 34
Contient "beau" : true

  L'essentiel en bref

Là où String est immuable et crée un nouvel objet à chaque modification, StringBuilder et StringBuffer maintiennent un tampon mutable — idéal pour les nombreuses concaténations ou transformations. Les deux partagent la même API : append() pour ajouter, insert() pour insérer, replace() et delete() pour modifier, reverse() pour inverser. La différence clé est la synchronisation : StringBuffer est thread-safe (méthodes synchronisées) au prix de performances moindres, tandis que StringBuilder est plus rapide mais réservé aux contextes mono-thread. En pratique, utilisez toujours StringBuilder sauf si votre code est explicitement multithread. Terminez toujours avec toString() pour récupérer un String immuable standard.