Quelle est la différence entre StringBuffer et StringBuilder

Publié le 9 Mai 2012

En java les strings sont des objets immuables. Ce qui signifie qu'ils ne sont pas modifiables, c'est à dire que lorsqu'on construit une string en ajoutant des caractères à chaque fois on recrée une nouvelle instance de string:

Par exemple:

String text = "du texte";
text += " et un peu plus"; // là on n'a pas juste rajouter quelques caractères à la chaine initiale mais on a créé une nouvelle chaine contenant le text initial et les caractères supplémentaires

 Comme à chaque opération on crée une nouvelle instance de String (avec allocation mémoire, etc) on impacte rapidement les perfs.

Pour y remedier le JDK fournie 2 classes qui représentent une séquence de caractères modifiables:

  • StringBuffer
  • StringBuilder

La différence est que StringBuffer est synchronisé pour garandir que les caractères seront insérés dans l'ordre chronologique des appels aux méthodes telles que append() ou insert().

Le second StringBuilder n'est pas du tout synchronisé (on y gagne en performance) mais il n'y a plus de garantie quand à la cohérence de la chaine obtenue à la fin.

Mais ça ne pose pas de problème tant qu'on travaille à l'intérieur d'un seul thread (ce qui est le cas la plupart du temps). C'est donc cette classe qu'il faut privilégier pour construire une séquence de caractère.

Voici les résultats d'un petit test que j'ai effectué pour comparer les performances lorsqu'on concatène des chaînes assez longues.

Dans mon test je construit une chaine contenant 100 fois la séquence "zeroonetwothreefourfivesixseveneightnine"

A chaque iteration je rajoute un chiffre dans ma chaîne il me faut donc 1000 iterations pour construire la chaine finale.

Ensuite je répère l'opération 1 000 000 de fois pour avoir des temps significatifs, et voici les résultats:

Concaténation de String 2050811 ms
Utilisation d'un StringBuffer 22560 ms
Utilisation d'un StringBuilder 20565 ms

On note que les StringBuffer et les StringBuilder sont presque 100 foix plus rapide qu'une concaténation de chaine. Le StringBuilder offre un gain de presque 10% par rapport au StringBuffer.

Voilà le code que j'ai utilisé:

import java.util.Arrays;
import java.util.List;

public class TestStringBuilding {

   private static final int NB_CONCAT = 1000;
   private static final int NB_RUN = 1000000;

   private static List<String> TOKENS = Arrays.asList("zero", "one", "thow", "three", "four", "five", "six", "seven", "eight", "nine");

   public static void main(String[] args){
      long start = System.currentTimeMillis();

      for(int loop = 0 ; loop < NB_RUN; loop++){
         String text = "";
         for(int i = 0; i < NB_CONCAT; i++){
            text += TOKENS.get(i % 10);
         }
      }
      long end = System.currentTimeMillis();
      System.out.println("String concatenation: "+(end-start)+" ms");

      start = System.currentTimeMillis();
      for(int loop = 0 ; loop < NB_RUN; loop++){
         StringBuffer text = new StringBuffer();
         for(int i = 0; i < NB_CONCAT; i++){
            text.append(TOKENS.get(i % 10));
         }
      }
      end = System.currentTimeMillis();
      System.out.println("StringBuffer append: "+(end-start)+" ms");

      start = System.currentTimeMillis();
      for(int loop = 0 ; loop < NB_RUN; loop++){
         StringBuilder text = new StringBuilder();
         for(int i = 0; i < NB_CONCAT; i++){
            text.append(TOKENS.get(i % 10));
         }
      }
      end = System.currentTimeMillis();
      System.out.println("StringBuilder append: "+(end-start)+" ms");
   }

Rédigé par Bliz

Publié dans #Java

Repost 0
Pour être informé des derniers articles, inscrivez vous :
Commenter cet article

jackomony 08/01/2013 11:38


merci bien.