Artículo

String, StringBuilder y StringBuffer en Java: diferencias

Diferencias entre String, StringBuilder y StringBuffer en Java: inmutabilidad, rendimiento al concatenar en bucles y seguridad entre hilos, con medición real.

En resumen: String es inmutable: cada modificación crea un objeto nuevo. StringBuilder es mutable y rápido: úsalo para construir texto en bucles. StringBuffer es como StringBuilder pero sincronizado, lo que lo hace más lento; hoy casi nunca se necesita. Para concatenaciones sueltas, + está bien: el compilador ya lo optimiza. Probado con Java 25, compatible desde Java 17.

Vídeo explicativo

Comparación rápida

StringStringBuilderStringBuffer
¿Mutable?NoSíSí
¿Seguro entre hilos?Sí (por ser inmutable)NoSí (métodos synchronized)
Rendimiento al concatenar en bucleMaloEl mejorAlgo peor que StringBuilder
DesdeJava 1.0Java 5Java 1.0
Úsalo paraCasi todoConstruir texto por partesCódigo antiguo que lo exija

Ejemplo con medición

public class Main {
    public static void main(String[] args) {
        String s = "Java";
        String t = s.concat(" 21");
        System.out.println("s = " + s + ", t = " + t);   // s no cambia

        StringBuilder sb = new StringBuilder("Java");
        sb.append(" 21").insert(0, "¡").append("!");
        System.out.println("StringBuilder: " + sb);
        sb.reverse();
        System.out.println("reverse(): " + sb);
        sb.setLength(0);
        System.out.println("setLength(0) deja: \"" + sb + "\"");

        StringBuffer buffer = new StringBuffer("hilo");
        buffer.append("-seguro");
        System.out.println("StringBuffer: " + buffer);

        // Medición orientativa: concatenar en bucle con + frente a StringBuilder
        int n = 20_000;
        long t0 = System.nanoTime();
        String acumulado = "";
        for (int i = 0; i < n; i++) {
            acumulado += i % 10;
        }
        long conMas = System.nanoTime() - t0;

        t0 = System.nanoTime();
        StringBuilder acc = new StringBuilder();
        for (int i = 0; i < n; i++) {
            acc.append(i % 10);
        }
        String resultado = acc.toString();
        long conBuilder = System.nanoTime() - t0;

        System.out.println("Mismo resultado: " + acumulado.equals(resultado));
        System.out.println("Con + en bucle: " + conMas / 1_000_000 + " ms");
        System.out.println("Con StringBuilder: " + conBuilder / 1_000_000 + " ms");
    }
}

Salida en nuestra máquina:

s = Java, t = Java 21
StringBuilder: ¡Java 21!
reverse(): !12 avaJ¡
setLength(0) deja: ""
StringBuffer: hilo-seguro
Mismo resultado: true
Con + en bucle: 33 ms
Con StringBuilder: 0 ms

Con solo 20.000 iteraciones, + en bucle ya tarda decenas de milisegundos y StringBuilder menos de uno. La diferencia crece de forma cuadrática: cada += copia todo el texto acumulado en un objeto nuevo. Es una medición orientativa, no un benchmark riguroso; para eso se usa JMH.

¿Entonces nunca uso +?

Al contrario: úsalo para concatenaciones en una línea ("Hola, " + nombre + "!"). Desde Java 9 el compilador las traduce a una llamada optimizada (StringConcatFactory), igual de rápida o más que un StringBuilder escrito a mano. El problema es solo dentro de bucles, donde cada vuelta crea un String nuevo.

Alternativas para casos concretos:

  • String.join(", ", lista) o Collectors.joining(", ") para unir colecciones.
  • "Precio: %.2f €".formatted(precio) para plantillas.
  • Text blocks ("""...""") para texto de varias líneas.

Por qué String es inmutable

Porque así puede compartirse sin riesgo entre hilos, usarse como clave en un HashMap (su hashCode no cambia) y reutilizarse desde el String pool, que explicamos en qué es el String Pool. La contrapartida es ese coste al modificarlo repetidamente.

Preguntas frecuentes

¿StringBuilder o StringBuffer?

StringBuilder. Construir un texto casi nunca se reparte entre varios hilos, y si se hiciera, la sincronización de StringBuffer método a método no basta para que la secuencia completa sea correcta.

¿Cómo comparo un StringBuilder con un String?

Con sb.toString().equals(texto) o con sb.compareTo(otro) entre builders. StringBuilder no sobrescribe equals, así que dos builders con el mismo texto no son equals.

¿Por qué == falla al comparar Strings?

Porque compara referencias, no contenido. Usa equals. Lo explicamos en == frente a equals.

Sigue aprendiendo

El manejo de texto, la inmutabilidad y las colecciones se trabajan en el curso de Java desde cero. Para medir y optimizar rendimiento en serio, el curso de Java avanzado.

string stringbuilder stringbuffer java concatenar strings rendimiento

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo