# 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](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-strings/) 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:

```java
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:

```java
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 Java](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/comandos-java/)`System.out.println`, te devolverá lo siguiente:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
AFGHIJKE
```

### `reverse()`

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

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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).


This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-stringbuilder/](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-stringbuilder/) for AI/LLM consumption.