La clase StringBuffer y StringBuilder¶

Java provee distintas clases para el trabajo con cadenas de texto. La más básica, la clase String. Sin embargo existen otras clases como StringBuffer y StringBuilder que resultan de interés porque facilitan cierto tipo de trabajos y aportan mayor eficiencia en determinados contextos.

StringBuilder¶

La clase StringBuilder es similar a la clase String en el sentido de que sirve para almacenar cadenas de caracteres. No obstante, presenta algunas diferencias relevantes. Señalaremos como características de StringBuilder a tener en cuenta:

Su tamaño y contenido pueden modificarse. Los objetos de éste tipo son mutables. Esto es una diferencia con los String.
Debe crearse con alguno de sus constructores asociados. No se permite instanciar directamente a una cadena como sí permiten los String.
Un StringBuilder está indexado. Cada uno de sus caracteres tiene un índice: 0 para el primero,1 para el segundo, etc.
Los métodos de StringBuilder no están sincronizados. Esto implica que es más eficiente que StringBuffer siempre que no se requiera trabajar con múltiples hilos (threads), que es lo más habitual.

Los constructores de StringBuilder se resumen en la siguiente tabla:

Constructor	Descripción	Ejemplo
`StringBuilder()`	Construye un `StringBuilder` vacío y con una capacidad por defecto de 16 caracteres.	`StringBuilder s = new StringBuilder();`
`StringBuilder(int capacidad)`	Se le pasa la capacidad (número de caracteres) como argumento.	`StringBuilder s = new StringBuilder(55);`
`StringBuilder(String str)`	Construye un `StringBuilder` en base al `String` que se le pasa como argumento.	`StringBuilder s = new StringBuilder("hola");`

Los métodos principales de StringBuilder se resumen en la siguiente tabla:

Retorno	Método	Explicación
`StringBuilder`	`append(...)`	Añade al final del `StringBuilder` un `String` o la representación en forma de `String` de un dato asociado a una variable primitiva.
`int`	`capacity()`	Devuelve la capacidad del `StringBuilder`.
`int`	`length()`	Devuelve el número de caracteres del `StringBuilder`.
`StringBuilder`	`reverse()`	Invierte el orden de los caracteres del `StringBuilder`.
`void`	`setCharAt(int indice, char ch)`	Cambia el carácter indicado en el primer argumento por el carácter que se le pasa en el segundo.
`char`	`charAt(int indice)`	Devuelve el carácter asociado a la posición que se le indica en el argumento.
`void`	`setLength(int nuevaLongitud)`	Modifica la longitud. La nueva longitud no puede ser menor que la longitud actual.
`String`	`toString()`	Convierte un `StringBuilder` en un `String`.
`StringBuilder`	`insert(int indiceIni, String cadena)`	Añade la cadena del segundo argumento a partir de la posición indicada en el primero.
`StringBuilder`	`delete(int indiceIni, int indiceFin)`	Borra la cadena de caracteres incluidos entre los dos índices indicados en los argumentos.
`StringBuilder`	`deleteCharAt(int indice)`	Borra el carácter indicado en el índice.
`StringBuilder`	`replace(int indiceIni, int indiceFin, String str)`	Reemplaza los caracteres comprendidos entre los dos índices por la cadena que se le pasa en el argumento.
`int`	`indexOf(String str)`	Analiza los caracteres de la cadena y encuentra el primer índice que coincide con el valor deseado.
`String`	`substring(int indiceIni, int indiceFin)`	Devuelve una cadena comprendida entre los dos índices.

StringBuffer¶

La clase StringBuffer es similar a la clase StringBuilder, siendo la principal diferencia que sus métodos están sincronizados, lo cual permite trabajar con múltiples hilos de ejecución (threads).

Los constructores y métodos de StringBuffer son los mismos que los de StringBuilder.

Constructor	Descripción	Ejemplo
`StringBuffer()`	Construye un `StringBuffer` vacío y con una capacidad por defecto de 16 caracteres.	`StringBuffer s = new StringBuffer();`
`StringBuffer(int capacidad)`	Se le pasa la capacidad (número de caracteres) como argumento.	`StringBuffer s = new StringBuffer(55);`
`StringBuffer(String str)`	Construye un `StringBuffer` en base al `String` que se le pasa como argumento.	`StringBuffer s = new StringBuffer("hola");`

Diferencias entre string, stringbuilder y stringbuffer¶

Vamos a enumerar las principales diferencias entre estas tres clases:

StringBuffer y StringBuilder son mutables, mientras que String es inmutable. Cada vez que modificamos un String se crea un objeto nuevo. Esto no ocurre con StringBuffer y StringBuilder.
Los objetos String se almacenan en el Constant String Pool que es un repositorio o almacén de cadenas, de valores de Strings. Esto se hace con el fin de que si creamos otro String, con el mismo valor, no se cree un nuevo objeto sino que se use el mismo y se asigne una referencia al objeto ya creado. Los objetos StringBuffer y StringBuilder se almacenan en el heap que es otro espacio de memoria usado en tiempo de ejecución para almacenar las instancias de clases, objetos y arrays. Realmente no nos interesa entrar a nivel de detalle en estas diferencias: simplemente, recordar que los objetos String tienen diferente tratamiento que los StringBuffer y StringBuilder.
La implementación de la clase StringBuffer es sincronizada, la de StringBuilder no.
El operador de concatenación "+" es implementado internamente por Java usando StringBuilder.

Actividades¶

PR 1017 (RA6 / IC1 / 5p). Crea un programa que reciba una frase de entrada del usuario y realice las siguientes operaciones utilizando las clases StringBuffer y StringBuilder:
1. Uso de StringBuilder:
  1. Crear un objeto de la clase StringBuilder con la frase ingresada.
  2. Realizar las siguientes operaciones sobre la cadena usando StringBuilder:
    - Añadir al final de la frase la palabra "¡Bienvenido!".
    - Invertir la cadena resultante.
    - Reemplazar todas las vocales de la cadena por el símbolo '*'.
2. Uso de StringBuffer:
  1. Crear un objeto de la clase StringBuffer con la frase original.
  2. Realizar las siguientes operaciones sobre la cadena usando StringBuffer:
    - Insertar al principio de la frase la palabra "Saludo: ".
    - Eliminar las primeras 5 letras de la cadena.
    - Convertir todos los caracteres a mayúsculas.
  Requisitos:
  - Asegúrate de que el programa maneje excepciones si el usuario introduce datos incorrectos o vacíos.
  - El programa debe mostrar la cadena resultante después de cada operación realizada con StringBuilder y StringBuffer.
  - Comenta el código explicando las funciones de cada parte del programa.