Java StringBuilder: funcionamiento de la clase modificable

La clase StringBuilder de Java puede utilizarse en lugar de un string tradicional. A diferencia de un string, esta clase permite hacer cambios directamente dentro de la secuencia de caracteres. Estas modificaciones pueden iniciarse a partir de distintos métodos.

Java StringBuilder como alternativa al string clásico

La clase Strings de Java no se puede modificar y no tiene subclases. Una alternativa a esta clase final en Java es StringBuilder, que crea una secuencia de caracteres que puede modificarse tras ser creada. En ese sentido, Java StringBuilder se parece a StringBuffer, ya que ambas clases desempeñan una tarea similar. Sin embargo, a diferencia de Buffer, StringBuilder no se sincroniza. Para trabajar con un único thread, esta opción es especialmente recomendable ya que se puede trabajar mucho más rápido que con la alternativa. Te explicamos qué es StringBuilder y qué opciones ofrece esta clase.

Sintaxis y usos

La sintaxis de StringBuilder en Java sigue siempre el mismo patrón y tiene el siguiente aspecto:

public final class StringBuilder
	extends Object
		implements Serializable, CharSequence

Para entender realmente cómo funciona esta clase y qué finalidad tiene, conviene primero echar un vistazo a la clase convencional string. Si se declara un objeto en string, posteriormente no se puede modificar. Para poder hacer cambios, has de crear un objeto y guardarlo con el valor modificado. Esto genera residuos de datos y puede perjudicar el rendimiento. En cambio, si usas StringBuilder para tu secuencia de caracteres, podrás modificarla sin tener que crear un string nuevo, reduciendo los residuos y mejorando así el rendimiento.

Constructores de la clase

La clase de Java StringBuilder tiene cuatro constructores que ayudan a convertir la cadena de caracteres al formato adecuado para la clase. También se utilizan para la configuración. A continuación, verás los constructores y sus funciones:

• StringBuilder(): genera un StringBuilder vacío con una capacidad máxima de 16 caracteres.
• StringBuilder(int capacity): crea un StringBuilder sin caracteres cuya cantidad máxima de caracteres se define mediante el argumento “capacity”.
• StringBuilder(CharSequence seq): genera un StringBuilder con los mismos caracteres que la secuencia char almacenada.
• StringBuilder(String str): crea un StringBuilder basándose en los strings almacenados.

Para entender cómo funcionan en la práctica los constructores, lo mejor es verlos en acción con un ejemplo de código. Así funcionan las cuatro opciones:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
	str.append("ABC");
	System.out.println("Primer Constructor = " + str.toString());
	StringBuilder str2 = new StringBuilder(5);
	System.out.println("Segundo Constructor = " + str2.capacity());
	StringBuilder str3 = new StringBuilder("ABCDEFGHIJK");
	System.out.println("Tercer Constructor = " + str3.toString());
	StringBuilder str4 = new StringBuilder(str3.toString());
	System.out.println("Cuarto Constructor = " + str4.toString());
	}
}

Si usas el comando JavaSystem.out.println, te devolverá lo siguiente:

Primer Constructor = ABC
Segundo Constructor = 5
Tercer Constructor = ABCDEFGHIJK
Cuarto Constructor = ABCDEFGHIJK

Ejemplos de métodos de StringBuilder en Java

Hay múltiples métodos para la clase de Java StringBuilder. Abajo te presentamos algunos de los más importantes con los fragmentos de código correspondientes.

append()

El método append() se usa para añadir un string a otro. append() dispone de distintos parámetros. En la práctica funciona de la siguiente manera:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.append("FGHIJK");
	System.out.println(str);
	}
}

Se emite lo siguiente:

ABCDEFGHIJK

insert()

El método insert() se usa en combinación con StringBuilder para añadir un string en un lugar concreto. A continuación tienes un ejemplo:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.insert(1,"FGHIJK");
	System.out.println(str);
	}
}

Devuelve lo siguiente:

AFGHIJKBCDEFGHIJK

Con el Integer (en este caso 1) decides la posición en la que debe incrustarse el string.

replace()

El método replace() sustituye un string o parte de un string, definida por beginIndex y endIndex. He aquí el ejemplo correspondiente:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.replace(1,4,"FGHIJK");
	System.out.println(str);
	}
}

Devuelve lo siguiente:

AFGHIJKE

reverse()

Con el método reverse() inviertes completamente el string almacenado. Visualízalo con el siguiente ejemplo:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.reverse();
	System.out.println(str);
	}
}

Esto emite lo siguiente:

EDCBA

delete()

Con el método delete() con StringBuilder en Java puedes borrar un string entero o solo una parte, que también se delimita con beginIndex y endIndex. Así se usa en el ejemplo:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.delete(1,4);
	System.out.println(str);
	}
}

Y devuelve:

AE

capacity()

El método capacity() devuelve el número máximo de caracteres actuales del StringBuilder de Java, que normalmente es 16. Si se supera esa cantidad, se sigue la fórmula “Longitud de caracteres anterior * 2 + 2”. De esta manera, si antes era 16, ahora se duplica (32) y se suma 2 (32). Echa un vistazo al siguiente ejemplo:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("Esto es otro ejemplo");
	System.out.println(str.capacity());
	}
}

Los resultados ahora son:

16
16
34

ensureCapacity()

El método ensureCapacity() se asegura de que el número de caracteres disponible corresponde al menos a un valor definido. Si no es así, la capacidad seguirá de nuevo la fórmula “Longitud de caracteres anterior * 2 + 2”. Consulta el ejemplo:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("Esto es otro ejemplo");
	System.out.println(str.capacity());
	str.ensureCapacity(5);
	System.out.println(str.capacity());
	str.ensureCapacity(40);
	System.out.println(str.capacity());
	}
}

Así, el programa devuelve lo siguiente:

16
16
34
34
70

Primero se tuvo en cuenta el valor estándar (16) dos veces, luego otras dos el valor duplicado más dos (34) y por último se duplicó de nuevo el valor y sumó dos (70).