Question Différence entre StringBuilder et StringBuffer


Quelle est la principale différence entre StringBuffer et StringBuilder? Y a-t-il des problèmes de performance au moment de prendre une décision?


1322
2017-12-10 04:34


origine


Réponses:


StringBuffer est synchronisé, StringBuilder n'est pas.


1452
2017-12-10 04:36



StringBuilder est plus rapide que StringBuffer parce que ce n'est pas synchronized.

Voici un test de référence simple:

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);
        }
    }
}

UNE essai donne le nombre de 2241 ms pour StringBuffer contre 753 ms pour StringBuilder.


664
2018-05-05 09:15



Fondamentalement, StringBuffer les méthodes sont synchronisées tout en StringBuilder ne sont pas.

Les opérations sont «presque» les mêmes, mais l'utilisation de méthodes synchronisées dans un seul thread est excessive.

C'est à peu près tout.

Citation de API StringBuilder:

Cette classe [StringBuilder] fournit une API compatible avec StringBuffer, mais sans garantie de synchronisation. Cette classe est conçue pour être utilisée comme remplacement direct de StringBuffer aux endroits où le buffer de chaînes était utilisé par un seul thread (comme c'est généralement le cas). Dans la mesure du possible, il est recommandé d'utiliser cette classe de préférence à StringBuffer Ce sera plus rapide dans la plupart des implémentations.

Donc, il a été fait pour le remplacer.

La même chose s'est produite avec Vector et ArrayList.


228
2017-12-10 04:37



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

StringBuffer ou StringBuilder

Simplement utiliser StringBuilder sauf si vous essayez vraiment de partager un tampon entre les threads. StringBuilder est le petit frère non synchronisé (moins de frais généraux = plus efficace) de l'original synchronisé StringBuffer classe.


151
2018-01-25 12:30



D'abord, voyons le similitudes: StringBuilder et StringBuffer sont mutables. Cela signifie que vous pouvez en changer le contenu au même endroit.

Différences: StringBuffer est mutable et synchronisé aussi bien. Où StringBuilder est mutable mais pas synchronisé par défaut.

Signification de synchronisé (synchronisation): Quand quelque chose est synchronisé, alors plusieurs threads peuvent accéder, et le modifier sans aucun problème ou effet secondaire. StringBuffer est synchronisé, vous pouvez donc l'utiliser avec plusieurs threads sans problème.

Lequel utiliser quand? StringBuilder: Lorsque vous avez besoin d'une chaîne, qui peut être modifiable, et qu'un seul thread l'accède et la modifie. StringBuffer: lorsque vous avez besoin d'une chaîne, qui peut être modifiable, et que plusieurs threads y accèdent et la modifient.

Remarque : N'utilisez pas StringBuffer inutilement, c'est-à-dire, ne l'utilisez pas si un seul thread est en train de modifier et d'y accéder car il a beaucoup de code de verrouillage et de déverrouillage qui prendra inutilement du temps CPU. N'utilisez pas de verrous sauf si cela est nécessaire.


74
2017-12-11 07:11



En un seul thread, StringBuffer n'est pas significativement plus lent que StringBuilder, grâce aux optimisations JVM. Et en multithreading, vous ne pouvez pas utiliser en toute sécurité un StringBuilder.

Voici mon 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 :
cordes: 319740
Tampons: 23
Constructeur: 7!

Donc, les constructeurs sont plus rapides que les tampons, et WAY plus rapide que la concaténation des chaînes. Maintenant, utilisons 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 prend 157 ms pour 100000 ajouts. Ce n'est pas le même test, mais comparé aux 37 ms précédents, vous pouvez supposer que Les extensions StringBuffers sont plus lentes avec l'utilisation multithread. La raison en est que le JIT / hotspot / compilateur / quelque chose fait des optimisations quand il détecte qu'il y a non besoin de vérifier les verrous.

Mais avec StringBuilder, vous avez java.lang.ArrayIndexOutOfBoundsException, car un thread concurrent essaie d'ajouter quelque chose là où il ne devrait pas.

Conclusion: vous n'avez pas besoin de chasser StringBuffers. Et là où vous avez des discussions, pensez à ce qu'elles font, avant d'essayer de gagner quelques nanosecondes.


42
2017-11-15 16:20



StringBuilder a été introduit dans Java 1.5 de sorte qu'il ne fonctionnera pas avec les JVM antérieures.

Du Javadocs:

La classe StringBuilder fournit une API compatible avec StringBuffer, mais sans garantie de synchronisation. Cette classe est conçue pour être utilisée comme remplacement direct de StringBuffer aux endroits où le buffer de chaînes était utilisé par un seul thread (comme c'est généralement le cas). Dans la mesure du possible, il est recommandé d'utiliser cette classe de préférence à StringBuffer car elle sera plus rapide dans la plupart des implémentations.


37
2017-12-10 04:38



Assez bonne question

Voici les différences, 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 banale :-

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


33
2018-04-11 20:25



StringBuilder n'est pas thread-safe. String Buffer est. Plus d'informations ici.

EDIT: Quant à la performance, après point chaud se lance, StringBuilder est le gagnant. Cependant, pour de petites itérations, la différence de performance est négligeable.


19
2017-12-10 04:41



StringBuilder et StringBuffer sont presque les mêmes. La différence est que StringBuffer est synchronisé et StringBuilder n'est pas. Bien que, StringBuilder est plus rapide que StringBuffer, la différence de performance est très faible. StringBuilder est le remplacement d'un SUN StringBuffer. Cela évite simplement la synchronisation de toutes les méthodes publiques. Plutôt que cela, leur fonctionnalité est la même.

Exemple de bon usage:

Si votre texte va changer et est utilisé par plusieurs threads, alors il vaut mieux utiliser StringBuffer. Si votre texte va changer mais est utilisé par un seul thread, alors utilisez StringBuilder.


19
2017-12-03 06:38



StringBuffer

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

pour cette raison, il ne permet pas à deux threads d'accéder simultanément à la même méthode. Chaque méthode peut être accédée par un fil à la fois.

Mais être thread-safe a aussi des désavantages lorsque les performances du StringBuffer sont dues à la propriété thread safe. Ainsi, StringBuilder est plus rapide que StringBuffer lorsqu'il appelle les mêmes méthodes de chaque classe.

La valeur StringBuffer peut être modifiée, cela signifie qu'elle peut être affectée à la nouvelle valeur. De nos jours, c'est une question d'entrevue la plus commune, les différences entre les classes ci-dessus. String Buffer peut être converti en chaîne en utilisant 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 identique à StringBuffer, c'est-à-dire qu'il stocke l'objet dans le tas et il peut également être modifié. La principale différence entre StringBuffer et StringBuilder est que StringBuilder n'est pas non plus thread-safe. StringBuilder est rapide car il n'est pas sûr pour les threads.

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

enter image description here

Ressource: Chaîne Vs StringBuffer Vs StringBuilder


18
2017-09-20 17:40