Différence entre StringBuilder et StringBuffer

StringBuilder est plus rapide que StringBuffer car il n'est pas synchronized.

Ici est un simple test de référence:

public class Main {
    public static void main(String[] args) {
        int N = 77777777;
        long t;

        {
            StringBuffer sb = new StringBuffer();
            t = System.currentTimeMillis();
            for (int i = N; i --> 0 ;) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }

        {
            StringBuilder sb = new StringBuilder();
            t = System.currentTimeMillis();
            for (int i = N; i > 0 ; i--) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }
    }
}

Un essai donne le nombre de 2241 ms pour StringBuffer vs 753 ms pour StringBuilder.

OriginalL'auteur polygenelubricants

Mais nécessaire pour obtenir la nette différence avec l'aide d'un exemple?

StringBuffer ou StringBuilder

Simplement utiliser StringBuilder à moins que vous êtes vraiment essayer de partager un tampon entre les threads. StringBuilder est la désynchronisation (moins de charge = plus d'efficacité), frère cadet de l'original synchronisé StringBuffer classe.

StringBuffer est venu en premier. Le soleil a été concerné avec exactitude dans toutes les conditions, alors ils ont fait synchronisé pour en faire thread-safe, juste au cas où.

StringBuilder est venu plus tard. La plupart des utilisations de StringBuffer étaient mono-thread et paient le coût de la synchronisation.

Depuis StringBuilder est un baisse-dans le remplacement pour StringBuffer sans la synchronisation, il n'y aurait pas de différences entre les exemples.

Si vous sont essayer de partager entre les threads, vous pouvez utiliser StringBuffer, mais d'examiner si de plus haut niveau de la synchronisation est nécessaire, par exemple, peut-être, au lieu d'utiliser StringBuffer, si vous synchronisez les méthodes qui utilisent le StringBuilder.

OriginalL'auteur Bert F

Dans un seul fils, StringBuffer est pas significativement plus lent que StringBuilder, grâce à la JVM des optimisations. Et dans le multithreading, vous ne pouvez pas l'utiliser en toute sécurité un StringBuilder.

Voici mon test (pas une référence, juste un test) :

public static void main(String[] args) {

    String withString ="";
    long t0 = System.currentTimeMillis();
    for (int i = 0 ; i < 100000; i++){
        withString+="some string";
    }
    System.out.println("strings:" + (System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuffer buf = new StringBuffer();
    for (int i = 0 ; i < 100000; i++){
        buf.append("some string");
    }
    System.out.println("Buffers : "+(System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuilder building = new StringBuilder();
    for (int i = 0 ; i < 100000; i++){
        building.append("some string");
    }
    System.out.println("Builder : "+(System.currentTimeMillis() - t0));
}

Résultats :

chaînes: 319740

Tampons : 23

Constructeur : 7 !

Ainsi les Constructeurs sont plus rapides que les Tampons, et de MANIÈRE plus rapide que la concaténation de chaînes de caractères.
Maintenant, nous allons utiliser un Exécuteur pour plusieurs threads :

public class StringsPerf {
public static void main(String[] args) {
ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
//With Buffer
StringBuffer buffer = new StringBuffer();
for (int i = 0 ; i < 10; i++){
executorService.execute(new AppendableRunnable(buffer));
}
shutdownAndAwaitTermination(executorService);
System.out.println(" Thread Buffer : "+ AppendableRunnable.time);
//With Builder
AppendableRunnable.time = 0;
executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
StringBuilder builder = new StringBuilder();
for (int i = 0 ; i < 10; i++){
executorService.execute(new AppendableRunnable(builder));
}
shutdownAndAwaitTermination(executorService);
System.out.println(" Thread Builder: "+ AppendableRunnable.time);
}
static void shutdownAndAwaitTermination(ExecutorService pool) {
pool.shutdown(); //code reduced from Official Javadoc for Executors
try {
if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
pool.shutdownNow();
if (!pool.awaitTermination(60, TimeUnit.SECONDS))
System.err.println("Pool did not terminate");
}
} catch (Exception e) {}
}
}
class AppendableRunnable<T extends Appendable> implements Runnable {
static long time = 0;
T appendable;
public AppendableRunnable(T appendable){
this.appendable = appendable;
}
@Override
public void run(){
long t0 = System.currentTimeMillis();
for (int j = 0 ; j < 10000 ; j++){
try {
appendable.append("some string");
} catch (IOException e) {}
}
time+=(System.currentTimeMillis() - t0);
}
}

Maintenant StringBuffers prendre 157 ms pour 100000 ajoute. Ce n'est pas le même test, mais par rapport à la précédente 37 ms, vous pouvez supposer que StringBuffers ajoute sont plus lents avec le multithreading utilisation. La raison en est que le JIT/point/compilateur/quelque chose qui le rend optimisations lorsqu'il détecte qu'il n'y a pas besoin pour vérifier les serrures.

Mais avec StringBuilder, vous avez java.lang.ArrayIndexOutOfBoundsException, parce qu'un des threads tente d'ajouter quelque chose où il ne devrait pas.

Conclusion est que vous n'avez pas à chasser StringBuffers. Et où vous avez threads, de penser à ce qu'ils font, avant d'essayer de gagner quelques nanosecondes.

OriginalL'auteur Nicolas Zozol

Assez Bonne Question

Voici les différences que j'ai remarqué :

StringBuffer :-

StringBuffer is  synchronized
StringBuffer is  thread-safe
StringBuffer is  slow (try to write a sample program and execute it, it will take more time than StringBuilder)

StringBuilder:-

 StringBuilder is not synchronized 
StringBuilder is not thread-safe
StringBuilder performance is better than StringBuffer.

Chose commune :-

Les deux ont les mêmes méthodes avec les mêmes signatures. Les deux sont mutables.

OriginalL'auteur Sireesh Yarlagadda

StringBuilder et StringBuffer sont presque les mêmes. La différence est que StringBuffer est synchronisé et StringBuilder ne l'est pas. Bien que, StringBuilder est plus rapide que StringBuffer, la différence de performance est très peu. StringBuilder est un SOLEIL de remplacement de StringBuffer. Il évite tout de synchronisation de toutes les méthodes publiques. Plutôt que cela, leur fonctionnement est le même.

Exemple de bonne utilisation:

Si votre texte est en passe de changer, et est utilisé par plusieurs threads, il est préférable d'utiliser StringBuffer. Si votre texte est en passe de changer, mais il est utilisé par un seul thread, puis utilisez StringBuilder.

OriginalL'auteur subodh ray

StringBuffer

StringBuffer est mutable signifie que l'on peut modifier la valeur de l'objet . L'objet créé par StringBuffer est stocké dans le tas . StringBuffer a les mêmes méthodes que la classe StringBuilder , mais chaque méthode dans StringBuffer est synchronisé qui est StringBuffer est thread-safe .

de ce fait, il ne permet pas à deux threads d'accéder simultanément à la même méthode . Chaque méthode peut être accessible par un seul thread à la fois .

Mais être thread-safe a des inconvénients aussi que la performance de l'StringBuffer hits en raison de thread-safe de la propriété . Ainsi StringBuilder est plus rapide que le StringBuffer lors de l'appel aux mêmes méthodes de chaque classe.

StringBuffer valeur peut être modifiée , cela signifie qu'il peut être attribué à la nouvelle valeur . Aujourd'hui, ses plus commune de la question de l'entrevue ,les différences entre les classes ci-dessus .
Tampon de chaîne peut être converti en chaîne de caractères en utilisant
la méthode toString ().

StringBuffer demo1 = new StringBuffer(“Hello”) ;
//The above object stored in heap and its value can be changed .
demo1=new StringBuffer(“Bye”);
//Above statement is right as it modifies the value which is allowed in the StringBuffer

StringBuilder

StringBuilder est le même que le StringBuffer , qu'en est-il des magasins de l'objet dans le tas et il peut également être modifié . La principale différence entre les StringBuffer et StringBuilder est que StringBuilder est pas thread-safe.
StringBuilder est rapide car il n'est pas thread-safe .

StringBuilder demo2= new StringBuilder(“Hello”);
//The above object too is stored in the heap and its value can be modified
demo2=new StringBuilder(“Bye”);
//Above statement is right as it modifies the value which is allowed in the StringBuilder

Ressource: String Vs StringBuffer Vs StringBuilder

OriginalL'auteur Virtual

La javadoc explique la différence:

Cette classe fournit une API compatible avec StringBuffer, mais sans aucune garantie de la synchronisation. Cette classe est conçu pour une utilisation en baisse-dans le remplacement pour StringBuffer dans des endroits où la chaîne de la mémoire tampon a été utilisé par un seul thread (comme c'est généralement le cas). Si possible, il est recommandé que cette classe sera utilisée de préférence à StringBuffer car il sera plus rapide dans la plupart des implémentations.

OriginalL'auteur skaffman

Un programme simple illustrant la différence entre StringBuffer et StringBuilder:

/**
* Run this program a couple of times. We see that the StringBuilder does not
* give us reliable results because its methods are not thread-safe as compared
* to StringBuffer.
* 
* For example, the single append in StringBuffer is thread-safe, i.e.
* only one thread can call append() at any time and would finish writing
* back to memory one at a time. In contrast, the append() in the StringBuilder 
* class can be called concurrently by many threads, so the final size of the 
* StringBuilder is sometimes less than expected.
* 
*/
public class StringBufferVSStringBuilder {
public static void main(String[] args) throws InterruptedException {
int n = 10; 
//*************************String Builder Test*******************************//
StringBuilder sb = new StringBuilder();
StringBuilderTest[] builderThreads = new StringBuilderTest[n];
for (int i = 0; i < n; i++) {
builderThreads[i] = new StringBuilderTest(sb);
}
for (int i = 0; i < n; i++) {
builderThreads[i].start();
}
for (int i = 0; i < n; i++) {
builderThreads[i].join();
}
System.out.println("StringBuilderTest: Expected result is 1000; got " + sb.length());
//*************************String Buffer Test*******************************//
StringBuffer sb2 = new StringBuffer();
StringBufferTest[] bufferThreads = new StringBufferTest[n];
for (int i = 0; i < n; i++) {
bufferThreads[i] = new StringBufferTest(sb2);
}
for (int i = 0; i < n; i++) {
bufferThreads[i].start();
}
for (int i = 0; i < n; i++) {
bufferThreads[i].join();
}
System.out.println("StringBufferTest: Expected result is 1000; got " + sb2.length());
}
}
//Every run would attempt to append 100 "A"s to the StringBuilder.
class StringBuilderTest extends Thread {
StringBuilder sb;
public StringBuilderTest (StringBuilder sb) {
this.sb = sb;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
sb.append("A");
}
}
}
//Every run would attempt to append 100 "A"s to the StringBuffer.
class StringBufferTest extends Thread {
StringBuffer sb2;
public StringBufferTest (StringBuffer sb2) {
this.sb2 = sb2;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
sb2.append("A");
}
}
}

OriginalL'auteur Kevin Lee

StringBuffer est synchronisé, mais StringBuilder ne l'est pas. En conséquence, StringBuilder est plus rapide que StringBuffer.

OriginalL'auteur Ahmad adawi

StringBuffer:

• Multi-Thread
• Synchronisé
• Lent que StringBuilder

StringBuilder

• Single-Thread
• Pas Synchronisé
• Plus rapide que jamais la Chaîne

OriginalL'auteur Asif Mushtaq

StringBuffer est utilisé pour stocker des chaînes de caractères qui seront modifiées (objets String ne peut pas être changé). Il s'étend automatiquement au besoin. Classes associées: String, CharSequence.

StringBuilder a été ajoutée dans Java 5. Il est en tous points identique à StringBuffer sauf qu'il n'est pas synchronisée, ce qui signifie que si plusieurs threads accèdent à la même heure, il pourrait y avoir des problèmes. Single-threaded programmes, le cas le plus courant, en évitant la surcharge de synchronisation fait l'objet StringBuilder très légèrement plus rapide.

OriginalL'auteur

Depuis StringBuffer est synchronisé, il a besoin de quelques efforts supplémentaires, donc basé sur perforamance, c'est un peu lente que StringBuilder.

OriginalL'auteur Shuhail Kadavath

La différence majeure est StringBuffer est synchronisé mais StringBuilder ne l'est pas.Si vous avez besoin d'utiliser plus d'un fil , puis StringBuffer est recommandé.Mais, ainsi que par la vitesse d'exécution StringBuilder est plus rapide que StringBuffer , parce que ses pas synchronisées .

OriginalL'auteur Java Developers Guide

Voici les tests de performance résultat pour Chaîne vs StringBuffer vs StringBuilder. Enfin, StringBuilder a remporté l'épreuve. Voir ci-dessous pour le code de test et résultat.

Code:

private static void performanceTestStringVsStringbuffereVsStringBuilder() {
//String vs StringBiffer vs StringBuilder performance Test
int loop = 100000;
long start = 0;
//String
String str = null;
start = System.currentTimeMillis();
for (int i = 1; i <= loop; i++) {
str += i + "test";
}
System.out.println("String - " + (System.currentTimeMillis() - start) + " ms");
//String buffer
StringBuffer sbuffer = new StringBuffer();
start = System.currentTimeMillis();
for (int i = 1; i <= loop; i++) {
sbuffer.append(i).append("test");
}
System.out.println("String Buffer - " + (System.currentTimeMillis() - start) + " ms");
//String builder
start = System.currentTimeMillis();
StringBuilder sbuilder = new StringBuilder();
for (int i = 1; i <= loop; i++) {
sbuffer.append(i).append("test");
}
System.out.println("String Builder - " + (System.currentTimeMillis() - start) + " ms");
}

M'exécutez sur ideone

Résultat:

100000 itération pour l'ajout d'un texte unique

String - 37489 ms
String Buffer - 5 ms
String Builder - 4 ms

10000 itération pour l'ajout d'un texte unique

String - 389 ms
String Buffer - 1 ms
String Builder - 1 ms

OriginalL'auteur Ganesa Vijayakumar

De chaque méthode présente dans StringBuffer est Synchronisé.
donc à un moment, un seul thread est autorisé à fonctionner StringBuffer objet.
Il Augmente le temps d'attente d'un Thread et Crée des problèmes de Performances
pour surmonter ce problème SOLEIL de Personnes introduites StringBuilder dans la version 1.5.

OriginalL'auteur Srinivas