En el desarrollo de aplicaciones Java, la manipulación de cadenas de texto es una tarea común. Si bien la clase String es fundamental, su naturaleza inmutable puede llevar a ineficiencias cuando se realizan múltiples modificaciones. Para estos escenarios, Java proporciona la clase StringBuffer, una alternativa mutable y segura para hilos, diseñada para la construcción y modificación dinámica de cadenas.

Creación e Inicialización de StringBuffer

La clase StringBuffer ofrece varios constructores para adaptarse a diferentes necesidades de inicialización:

• public StringBuffer(): Crea un búfer de cadena vacío con una capacidad inicial por defecto de 16 caracteres.
• public StringBuffer(int capacidad): Permite especificar la capacidad inicial del búfer. Esto es útil para optimizar el rendimiento si se conoce de antemano el tamaño aproximado de la cadena.
• public StringBuffer(String str): Inicializa el búfer con el contenido de una cadena String existente, añadiendo una capacidad adicional de 16 caracteres.

A continuación, se muestran ejemplos de cómo instanciar un objeto StringBuffer:

// Búfer vacío con capacidad predeterminada
StringBuffer bufferVacio = new StringBuffer();
System.out.println("Capacidad inicial: " + bufferVacio.capacity()); // 16

// Búfer con capacidad específica
StringBuffer bufferCapacidad = new StringBuffer(50);
System.out.println("Capacidad definida: " + bufferCapacidad.capacity()); // 50

// Búfer inicializado con una cadena
String textoBase = "Programación";
StringBuffer bufferInicializado = new StringBuffer(textoBase);
System.out.println("Contenido: " + bufferInicializado);
System.out.println("Longitud: " + bufferInicializado.length()); // 12
System.out.println("Capacidad (Longitud + 16): " + bufferInicializado.capacity()); // 12 + 16 = 28
 

Métodos Clave para la Manipulación de Cadenas

StringBuffer proporciona un conjunto rico de métodos para modificar cadenas de manera eficiente. A diferencia de String, estas operaciones modifican el búfer existente sin crear nuevos objetos en cada paso, lo que mejora significativamente el rendimiento en escenarios de alta manipulación.

Añadir Contenido (append)

El método append() es fundamental para concatenar datos al final del búfer. Puede aceptar varios tipos de datos, convirtiéndolos a su representación de cadena.

StringBuffer mensaje = new StringBuffer("Hola");
mensaje.append(" Mundo");
mensaje.append(2023); // Añade el entero 2023
mensaje.append(true); // Añade el booleano true
System.out.println(mensaje); // Salida: Hola Mundo2023true
 

Insertar Contenido (insert)

Para añadir contenido en una posición específica dentro del búfer, se utiliza el método insert().

StringBuffer frase = new StringBuffer("Java es fascinante.");
frase.insert(8, "muy "); // Inserta "muy " en la posición 8
System.out.println(frase); // Salida: Java es muy fascinante.
 

Eliminar Caracteres (deleteCharAt, delete)

Existen métodos para eliminar caracteres individuales o un rango de caracteres.

• deleteCharAt(int indice): Elimina el carácter en el índice especificado.
• delete(int inicio, int fin): Elimina una subcadena desde el índice de inicio (inclusive) hasta el índice final (exclusive).

StringBuffer textoModificable = new StringBuffer("Ejemplo de eliminación.");
textoModificable.deleteCharAt(6); // Elimina la 'o' en "Ejemplo"
System.out.println(textoModificable); // Salida: Ejempl de eliminación.

textoModificable.delete(0, 7); // Elimina "Ejempl "
System.out.println(textoModificable); // Salida: de eliminación.
 

Reemplazar Contenido (replace)

El método replace() permite sustituir una porción del búfer con una nueva cadena.

StringBuffer cadenaPlantilla = new StringBuffer("El año actual es [AÑO].");
cadenaPlantilla.replace(17, 21, "2024"); // Reemplaza "[AÑO]" con "2024"
System.out.println(cadenaPlantilla); // Salida: El año actual es 2024.
 

Envertir el Búfer (reverse)

El método reverse() invierte el orden de los caracteres en el búfer.

StringBuffer palabra = new StringBuffer("reconocer");
palabra.reverse();
System.out.println(palabra); // Salida: reconocer (es un palíndromo)

StringBuffer fraseOriginal = new StringBuffer("Esto es un ejemplo.");
fraseOriginal.reverse();
System.out.println(fraseOriginal); // Salida: .olpmeje nu se otsE
 

Obtener Subcadenas (substring)

Para extraer partes del búfer como nuevos objetos String, se utilizan los métodos substring().

• substring(int inicio): Retorna una subcadena desde el índice de inicio hasta el final del búfer.
• substring(int inicio, int fin): Retorna una subcadena desde el índice de inicio (inclusive) hasta el índice final (exclusive).

StringBuffer datos = new StringBuffer("ID_007:Nombre_Juan:Edad_30");
String id = datos.substring(0, 6); // Extrae "ID_007"
String nombre = datos.substring(13, 17); // Extrae "Juan"
String resto = datos.substring(18); // Extrae "Edad_30"

System.out.println("ID: " + id);
System.out.println("Nombre: " + nombre);
System.out.println("Resto: " + resto);
 

StringBuffer vs. String: Mutabilidad y Rendimienot

La diferencia fundamental entre String y StringBuffer radica en su mutabilidad:

• String: Es una clase inmutable. Cada vez que se modifica un objeto String (por ejemplo, con concatenación usando + o el método concat()), se crea un *nuevo* objeto String en la memoria. El objeto original permanece sin cambios. Esto puede ser ineficiente en términos de rendimiento y uso de memoria para operaciones repetitivas de modificación.
• StringBuffer: Es una clase mutable. Las operaciones como append(), insert(), delete() o replace() modifican el contenido del búfer *en el mismo objeto*. Esto evita la creación excesiva de objetos y es más eficiente para construir o manipular cadenas extensas o que requieren muchas modificaciones. Además, StringBuffer es sincronizada (thread-safe), lo que la hace adecuada para entornos multihilo.

Cada objeto StringBuffer mantiene una capacidad interna. Cuando el tamaño de la cadena excede esta capacidad, el búfer automáticamente la expande para acomodar el nuevo contenido, aunque esto implica una pequeña sobrecarga. Entender esta distinción es crucial para elegir la clase adecuada según el caso de uso y optimizar el rendimiento de las aplicaciones Java.