Java Stri­n­g­Bui­l­der: fu­n­cio­na­mie­n­to de la clase mo­di­fi­ca­ble

La clase Stri­n­g­Bui­l­der de Java puede uti­li­zar­se en lugar de un string tra­di­cio­nal. A di­fe­re­n­cia de un string, esta clase permite hacer cambios di­re­c­ta­me­n­te dentro de la secuencia de ca­ra­c­te­res. Estas mo­di­fi­ca­cio­nes pueden iniciarse a partir de distintos métodos.

Java Stri­n­g­Bui­l­der como al­te­r­na­ti­va al string clásico

La clase Strings de Java no se puede modificar y no tiene subclases. Una al­te­r­na­ti­va a esta clase final en Java es Stri­n­g­Bui­l­der, que crea una secuencia de ca­ra­c­te­res que puede mo­di­fi­car­se tras ser creada. En ese sentido, Java Stri­n­g­Bui­l­der se parece a Stri­n­g­Bu­f­fer, ya que ambas clases de­sem­pe­ñan una tarea similar. Sin embargo, a di­fe­re­n­cia de Buffer, Stri­n­g­Bui­l­der no se si­n­cro­ni­za. Para trabajar con un único thread, esta opción es es­pe­cia­l­me­n­te re­co­me­n­da­ble ya que se puede trabajar mucho más rápido que con la al­te­r­na­ti­va. Te ex­pli­ca­mos qué es Stri­n­g­Bui­l­der y qué opciones ofrece esta clase.

Sintaxis y usos

La sintaxis de Stri­n­g­Bui­l­der 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 co­n­ve­n­cio­nal string. Si se declara un objeto en string, po­s­te­rio­r­me­n­te no se puede modificar. Para poder hacer cambios, has de crear un objeto y guardarlo con el valor mo­di­fi­ca­do. Esto genera residuos de datos y puede pe­r­ju­di­car el re­n­di­mie­n­to. En cambio, si usas Stri­n­g­Bui­l­der para tu secuencia de ca­ra­c­te­res, podrás mo­di­fi­car­la sin tener que crear un string nuevo, re­du­cie­n­do los residuos y mejorando así el re­n­di­mie­n­to.

Co­n­s­tru­c­to­res de la clase

La clase de Java Stri­n­g­Bui­l­der tiene cuatro co­n­s­tru­c­to­res que ayudan a convertir la cadena de ca­ra­c­te­res al formato adecuado para la clase. También se utilizan para la co­n­fi­gu­ra­ción. A co­n­ti­nua­ción, verás los co­n­s­tru­c­to­res y sus funciones:

• StringBuilder(): genera un Stri­n­g­Bui­l­der vacío con una capacidad máxima de 16 ca­ra­c­te­res.
• StringBuilder(int capacity): crea un Stri­n­g­Bui­l­der sin ca­ra­c­te­res cuya cantidad máxima de ca­ra­c­te­res se define mediante el argumento “capacity”.
• StringBuilder(CharSequence seq): genera un Stri­n­g­Bui­l­der con los mismos ca­ra­c­te­res que la secuencia char al­ma­ce­na­da.
• StringBuilder(String str): crea un Stri­n­g­Bui­l­der basándose en los strings al­ma­ce­na­dos.

Para entender cómo funcionan en la práctica los co­n­s­tru­c­to­res, 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 Stri­n­g­Bui­l­der en Java

Hay múltiples métodos para la clase de Java Stri­n­g­Bui­l­der. Abajo te pre­se­n­ta­mos algunos de los más im­po­r­ta­n­tes con los fra­g­me­n­tos de código co­rre­s­po­n­die­n­tes.

append()

El método append() se usa para añadir un string a otro. append() dispone de distintos pa­rá­me­tros. 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 co­m­bi­na­ción con Stri­n­g­Bui­l­der para añadir un string en un lugar concreto. A co­n­ti­nua­ció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 in­cru­s­tar­se el string.

replace()

El método replace() sustituye un string o parte de un string, definida por be­gi­nI­n­dex y endIndex. He aquí el ejemplo co­rre­s­po­n­die­n­te:

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 co­m­ple­ta­me­n­te el string al­ma­ce­na­do. Vi­sua­lí­za­lo 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 Stri­n­g­Bui­l­der en Java puedes borrar un string entero o solo una parte, que también se delimita con be­gi­nI­n­dex 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 ca­ra­c­te­res actuales del Stri­n­g­Bui­l­der de Java, que no­r­ma­l­me­n­te es 16. Si se supera esa cantidad, se sigue la fórmula “Longitud de ca­ra­c­te­res 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 re­su­l­ta­dos ahora son:

16
16
34

ensureCapacity()

El método ensureCapacity() se asegura de que el número de ca­ra­c­te­res di­s­po­ni­ble co­rre­s­po­n­de al menos a un valor definido. Si no es así, la capacidad seguirá de nuevo la fórmula “Longitud de ca­ra­c­te­res 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).