AOWS

Java nos proporciona varias clases a la hora de trabajar con cadenas, cada una tiene sus características que la hace más o menos adecuada dependiendo del uso que se le vaya a dar.

Lo más utilizado son sin duda objetos de tipo String, al proporcionar suficiente potencial para la mayor parte de los casos.

La clase StringBuffer permite guardar cadenas que cambiarán en la ejecución del programa (a diferencia de los objetos String normales, que son inmutables).

Una clase parecida, StringBuilder, llegó con Java 5. Es idéntica a la anterior salvo que no es síncrona, lo que significa que puede haber problemas si es una variable a la que accedan diferentes threads. Sin embargo, para la mayoría de las aplicaciones (donde se ejecuta un solo hilo) supone una mejora de rendimiento sobre StringBuffer.

Cómo se usan

El método principal (o al menos el más usado) de ambas clases es append.

// creamos un StringBuffer vacío
StringBuffer sb = new StringBuffer();
// el tamaño va aumentando a medida que vayamos añadiendo caracteres
// el método append convierte automáticamente cualquier tipo en String (llamando al método toString())
sb.append("Esto es una prueba");
// también podemos insertar en una posición determinada
sb.insert(4, " no"); // sb = "Esto no es una prueba"
// o borrar trozos de la cadena
sb.delete(4, 11); // sb = "Esto prueba"

También es posible hacer llamadas encadenadas:

sb.append("Esto ").append("es ").append("una prueba");

StringBuffer vs String

Como acabos de comentar, un objeto de tipo String es inmutable, lo cual quiere decir que cada vez que modificamos su contenido se crea un nuevo objeto (con la cadena nueva) y se desecha el anterior.

Por ejemplo:

String cadena = new String("Cuenta: ");
for (int i=0; i<100; i++) {
   cadena += " " + i + " ";
}
// cadena = "Cuenta: 1 2 3 4 5 ... 99"

Este código crea dentro del bucle 99 objetos de tipo String, y en cada uno de ellos va guardando el nuevo contenido. Esto por supuesto no es eficiente, un problema que podemos resolver con StringBuffer:

StringBuffer cadena = new StringBuffer("Cuenta: ");
for (int i=0; i<100; i++) {
   cadena.append(" " + i + " ");
}
// cadena = "Cuenta: 1 2 3 4 5 ... 99"

En esta ocasión sólo se crea un objeto, al que se le van añadiendo las cadenas con el método append. Lógicamente esto también tiene un coste computacional, pero éste es inferior al que supone crear un nuevo objeto. De todos modos podemos reservar un espacio inicial de forma que no sea necesario hacerlo en cada iteración del bucle, mejorando aún más el rendimiento.

// creamos espacio para 120 caracteres
StringBuffer cadena = new StringBuffer(120);
// procedemos como antes
cadena.append("Cuenta: ");
for (int i=0; i<100; i++) {
   cadena.append(" " + i + " ");
}
// cadena = "Cuenta: 1 2 3 4 5 ... 99"

Cuándo usar uno y cuándo usar otro

En definitiva:

• Si el texto no va a cambiar, utilizar String.
• Si va a cambiar, y la aplicación va a tener un solo hilo de ejecución, utilizar StringBuilder.
• Si el texto cambia durante la ejecución, y la aplicación que accede a él es multi-thread, utilizaremos StringBuffer.

Basado en StringBuffer and StringBuilder.