Pregunta Diferencia entre StringBuilder y StringBuffer


¿Cuál es la principal diferencia entre StringBuffer y StringBuilder? ¿Hay problemas de rendimiento al decidir sobre alguno de estos?


1322
2017-12-10 04:34


origen


Respuestas:


StringBuffer está sincronizado, StringBuilder no es.


1452
2017-12-10 04:36



StringBuilder es más rápido que StringBuffer porque no es synchronized.

Aquí hay una prueba de referencia 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);
        }
    }
}

UN prueba de funcionamiento da los números de 2241 ms para StringBuffer vs 753 ms para StringBuilder.


664
2018-05-05 09:15



Básicamente, StringBuffer los métodos están sincronizados mientras StringBuilder no son.

Las operaciones son "casi" lo mismo, pero el uso de métodos sincronizados en un solo subproceso es excesivo.

Eso es más o menos sobre eso.

Cita de API de StringBuilder:

Esta clase [StringBuilder] proporciona una API compatible con StringBuffer, pero sin garantía de sincronización. Esta clase está diseñada para usarse como un reemplazo directo para StringBuffer en lugares donde el búfer de cadena estaba siendo utilizado por un solo hilo (como generalmente es el caso). Siempre que sea posible, se recomienda que esta clase se use con preferencia a StringBuffer como será más rápido en la mayoría de las implementaciones.

Entonces fue hecho para sustituirlo.

Lo mismo sucedió con Vector y ArrayList.


228
2017-12-10 04:37



¿Pero era necesario obtener la clara diferencia con la ayuda de un ejemplo?

StringBuffer o StringBuilder

Simplemente usa StringBuilder a menos que realmente esté tratando de compartir un búfer entre hilos. StringBuilder es el hermano menor no sincronizado (menos sobrecarga = más eficiente) del sincronizado original StringBuffer clase.


151
2018-01-25 12:30



Primero veamos el similitudes: Tanto StringBuilder como StringBuffer son mutables. Eso significa que puede cambiar el contenido de ellos, en la misma ubicación.

Diferencias: StringBuffer es mutable y sincronizado también. Donde como StringBuilder es mutable pero no sincronizado por defecto.

Significado de sincronización (sincronización): Cuando algo está sincronizado, múltiples subprocesos pueden acceder y modificarlo sin ningún problema o efecto secundario. StringBuffer está sincronizado, por lo que puede usarlo con múltiples hilos sin ningún problema.

¿Cuál usar cuando? StringBuilder: cuando necesita una cadena, que puede ser modificable, y solo un hilo está accediendo y modificándola. StringBuffer: cuando necesita una cadena, que puede ser modificable, y múltiples hilos están accediendo y modificándola.

Nota : No use StringBuffer innecesariamente, es decir, no lo use si solo un hilo está modificando y accediendo a él, ya que tiene muchos códigos de bloqueo y desbloqueo para la sincronización, lo que requerirá innecesariamente tiempo de CPU. No use cerraduras a menos que sea necesario.


74
2017-12-11 07:11



En hilos individuales, StringBuffer no es significativamente más lento que StringBuilder, gracias a las optimizaciones de JVM. Y en multihilo, no puede usar de forma segura un StringBuilder.

Aquí está mi prueba:

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

Resultados:
cuerdas: 319740
Buffers: 23
Constructor: 7!

Por lo tanto, los constructores son más rápidos que los búferes, y mucho más rápidos que la concatenación de cadenas. Ahora usemos un Ejecutor para múltiples hilos:

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

Ahora los StringBuffers toman 157 ms para 100000 anexos. No es la misma prueba, pero en comparación con los 37 ms anteriores, puedes asumir que Los StringBuffers son más lentos con el uso de subprocesos múltiples. La razón es que JIT / hotspot / compiler / something hace optimizaciones cuando detecta que hay no necesidad de verificar bloqueos.

Pero con StringBuilder, tienes java.lang.ArrayIndexOutOfBoundsException, porque un hilo concurrente intenta agregar algo donde no debería.

La conclusión es que no tienes que perseguir StringBuffers. Y donde tenga hilos, piense en lo que están haciendo, antes de intentar ganar unos nanosegundos.


42
2017-11-15 16:20



StringBuilder se introdujo en Java 1.5 por lo que no funcionará con las JVM anteriores.

Desde el Javadocs:

La clase StringBuilder proporciona una API compatible con StringBuffer, pero sin garantía de sincronización. Esta clase está diseñada para usarse como un reemplazo directo para StringBuffer en lugares donde el búfer de cadena estaba siendo utilizado por un solo hilo (como generalmente es el caso). Siempre que sea posible, se recomienda que esta clase se use con preferencia a StringBuffer, ya que será más rápida en la mayoría de las implementaciones.


37
2017-12-10 04:38



Buena pregunta

Estas son las diferencias, he notado:

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.

Cosa común :-

Ambos tienen los mismos métodos con las mismas firmas. Ambos son mutables


33
2018-04-11 20:25



StringBuilder no es seguro para subprocesos. String Buffer es. Más información aquí.

EDITAR: En cuanto a rendimiento, después punto de acceso entra en juego, StringBuilder es el ganador. Sin embargo, para pequeñas iteraciones, la diferencia de rendimiento es insignificante.


19
2017-12-10 04:41



StringBuilder y StringBuffer son casi lo mismo. La diferencia es que StringBuffer está sincronizado y StringBuilder no es. A pesar de que, StringBuilder es más rápido que StringBuffer, la diferencia en el rendimiento es muy pequeña. StringBuilder es un reemplazo de SUN StringBuffer. Simplemente evita la sincronización de todos los métodos públicos. En lugar de eso, su funcionalidad es la misma.

Ejemplo de buen uso:

Si su texto va a cambiar y es utilizado por múltiples hilos, entonces es mejor usar StringBuffer. Si su texto va a cambiar pero lo usa un solo hilo, use StringBuilder.


19
2017-12-03 06:38



StringBuffer

StringBuffer es mutable significa que uno puede cambiar el valor del objeto. El objeto creado a través de StringBuffer se almacena en el montón. StringBuffer tiene los mismos métodos que StringBuilder, pero cada método en StringBuffer está sincronizado, es decir, StringBuffer es seguro para subprocesos.

debido a esto, no permite que dos hilos accedan simultáneamente al mismo método. Cada método se puede acceder por un hilo a la vez.

Pero estar seguro de subprocesos también tiene desventajas, ya que el rendimiento de StringBuffer golpea debido a la propiedad de seguridad de subprocesos. Por lo tanto, StringBuilder es más rápido que StringBuffer al llamar a los mismos métodos de cada clase.

El valor de StringBuffer se puede cambiar, significa que se puede asignar al nuevo valor. Hoy en día es una pregunta de entrevista más común, las diferencias entre las clases anteriores. String Buffer se puede convertir a la cadena mediante el uso método 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 es igual que StringBuffer, es decir, almacena el objeto en el montón y también se puede modificar. La principal diferencia entre StringBuffer y StringBuilder es que StringBuilder tampoco es seguro para subprocesos. StringBuilder es rápido ya que no es seguro para subprocesos.

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

Recurso: String Vs StringBuffer Vs StringBuilder


18
2017-09-20 17:40