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:
Stringes inmutable: cada modificación crea un objeto nuevo.StringBuilderes mutable y rápido: úsalo para construir texto en bucles.StringBufferes comoStringBuilderpero 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
String | StringBuilder | StringBuffer | |
|---|---|---|---|
| ¿Mutable? | No | Sí | Sí |
| ¿Seguro entre hilos? | Sí (por ser inmutable) | No | Sí (métodos synchronized) |
| Rendimiento al concatenar en bucle | Malo | El mejor | Algo peor que StringBuilder |
| Desde | Java 1.0 | Java 5 | Java 1.0 |
| Úsalo para | Casi todo | Construir texto por partes | Có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)oCollectors.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.
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.