0Pricing
Java Academy · Lección

StringBuilder frente a StringBuffer

Compromisos de seguridad entre hilos

StringBuilder frente a StringBuffer es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Dos clases mutables

Java tiene dos clases mutables para cadenas: StringBuilder y StringBuffer. Sus API son prácticamente idénticas, pero se diferencian en un aspecto fundamental: la seguridad de hilos.

La misma API

Ambas clases ofrecen append, insert, delete, reverse y los demás métodos. El código que usa una normalmente puede cambiarse para usar la otra modificando solo el nombre del tipo.

public class Main {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello").append(", ").append("World");
        System.out.println(sb);
    }
}

StringBuffer está sincronizado

Los métodos de StringBuffer están sincronizados, lo que significa que varios hilos pueden modificar de forma segura la misma instancia. Esta seguridad tiene un pequeño coste de rendimiento.

public class Main {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("thread-safe");
        buffer.append("!");
        System.out.println(buffer);
    }
}

StringBuilder no está sincronizado

StringBuilder omite la sincronización, por lo que es más rápido. La contrapartida es que no es seguro compartir una instancia entre varios hilos sin coordinación externa.

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("fast");
        builder.append("!");
        System.out.println(builder);
    }
}

Cuándo usar StringBuilder

Use StringBuilder en el caso habitual: al construir cadenas dentro de un único método o hilo. Es la opción predeterminada para casi todo el código cotidiano.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            sb.append("#");
        }
        System.out.println(sb);
    }
}

Cuándo usar StringBuffer

Use StringBuffer únicamente cuando la misma instancia del builder se comparta y modifique realmente desde varios hilos. En la práctica, esto es poco frecuente.

public class Main {
    public static void main(String[] args) {
        StringBuffer shared = new StringBuffer("log: ");
        shared.append("event A; ");
        shared.append("event B");
        System.out.println(shared);
    }
}

Las variables locales no se comparten

Un builder declarado y utilizado únicamente dentro de un método nunca es visible para otros hilos, por lo que StringBuilder siempre es correcto en ese caso. La falta de sincronización no puede causar ningún problema.

public class Main {
    static String build() {
        StringBuilder sb = new StringBuilder();
        sb.append("local only");
        return sb.toString();
    }
    public static void main(String[] args) {
        System.out.println(build());
    }
}

Diferencia de rendimiento

La sobrecarga de sincronización de StringBuffer hace que sea más lento en aplicaciones de un solo hilo. En bucles ajustados, StringBuilder ofrece un mejor rendimiento.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append('x');
        }
        System.out.println("Built length: " + sb.length());
    }
}

Nota histórica

StringBuffer apareció primero, en las primeras versiones de Java. StringBuilder se añadió en Java 5 como alternativa más rápida y no sincronizada para el caso habitual de un solo hilo.

Elegir correctamente

Utilice StringBuilder como opción predeterminada. Cambie a StringBuffer únicamente cuando pueda demostrar que una misma instancia se comparte entre varios hilos. De lo contrario, pagará por una seguridad que no necesita.

public class Main {
    public static void main(String[] args) {
        StringBuilder result = new StringBuilder();
        result.append("Use StringBuilder ").append("by default");
        System.out.println(result);
    }
}

Ambos se convierten en String

Cualquiera de las dos clases produce un String inmutable mediante toString(). La elección entre ellas solo afecta a la construcción, no al resultado final.

public class Main {
    public static void main(String[] args) {
        String a = new StringBuilder("one").toString();
        String b = new StringBuffer("two").toString();
        System.out.println(a + " " + b);
    }
}

Comprobación rápida

¿Cuál es la diferencia principal entre StringBuilder y StringBuffer?

Repaso

Ha aprendido cuáles son las ventajas y desventajas:

  • Ambas tienen API prácticamente idénticas
  • StringBuffer está sincronizado (es seguro para subprocesos, pero más lento)
  • StringBuilder no está sincronizado (es más rápido)
  • Utilice StringBuilder como opción predeterminada para construir cadenas en un solo hilo
  • Utilice StringBuffer únicamente para instancias que realmente se compartan

Preguntas frecuentes

¿La lección «StringBuilder frente a StringBuffer» es gratis?

Sí — el texto completo de «StringBuilder frente a StringBuffer» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «StringBuilder frente a StringBuffer»?

Compromisos de seguridad entre hilos Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «StringBuilder frente a StringBuffer»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Por qué las cadenas son inmutables
  2. Construcción de cadenas con StringBuilder
  3. Métodos de StringBuilder
  4. StringBuilder frente a StringBuffer
← Volver a Java Academy