# Java StringBuilder: funcionamento da classe modificável

A classe StringBuilder do Java pode ser utilizada em vez de uma string tradicional. Ao contrário de uma string, esta classe permite fazer alterações diretamente dentro da sequência de caracteres. Estas modificações podem ser iniciadas a partir de diferentes métodos.

## Java StringBuilder como alternativa ao string clássico

A classe [Strings do Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/strings-java/) não pode ser modificada e não tem subclasses. Uma alternativa a esta classe final no Java é o StringBuilder, que cria uma sequência de caracteres que **pode ser modificada após ser criada**. Nesse sentido, o Java StringBuilder é semelhante ao StringBuffer, uma vez que ambas as classes desempenham uma tarefa semelhante. No entanto, ao contrário do Buffer, o StringBuilder não é sincronizado. Para trabalhar com um único thread, esta opção é especialmente recomendável, pois permite trabalhar muito mais rapidamente do que com a alternativa. Explicamos o que é o StringBuilder e quais as opções que esta classe oferece.

## Sintaxe e usos

A sintaxe do StringBuilder em Java segue sempre o mesmo padrão e tem a seguinte aparência:

```java
public final class StringBuilder
	extends Object
		implements Serializable, CharSequence
```

Para entender realmente como essa classe funciona e qual é a sua finalidade, convém primeiro dar uma olhada na classe string convencional. Se um objeto for declarado em string, ele não poderá ser modificado posteriormente. Para fazer alterações, é necessário criar um objeto e guardá-lo com o valor modificado. Isso gera resíduos de dados e pode prejudicar o desempenho. Por outro lado, se usar o StringBuilder para a sua sequência de caracteres, poderá modificá-la **sem ter de criar uma nova string**, reduzindo o desperdício e melhorando assim o desempenho.

## Construtores da classe

A classe Java StringBuilder possui quatro construtores que ajudam a **converter a cadeia de caracteres para o formato adequado para a classe**. Eles também são utilizados para configuração. A seguir, você verá os construtores e suas funções:

- `StringBuilder()`: gera um StringBuilder vazio com uma capacidade máxima de 16 caracteres.
- `StringBuilder(int capacity)`: cria um StringBuilder sem caracteres cuja quantidade máxima de caracteres é definida pelo argumento “capacity”.
- `StringBuilder(CharSequence seq)`: gera um StringBuilder com os mesmos caracteres que a sequência char armazenada.
- `StringBuilder(String str)`: cria um StringBuilder com base nas strings armazenadas.

Para entender como os construtores funcionam na prática, o melhor é vê-los em ação com um exemplo de código. Veja como funcionam as quatro opções:

```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());
	}
}
```

Se utilizar o comando`System.out.println`, obterá o seguinte resultado:

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

## Exemplos de métodos StringBuilder em Java

Existem vários métodos para a classe Java StringBuilder. Abaixo apresentamos alguns dos mais importantes com os fragmentos de código correspondentes.

### `append()`

O método `append()` é usado para adicionar uma string a outra. `append()` tem diferentes parâmetros. Na prática, funciona da seguinte maneira:

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

É emitido o seguinte:

```java
ABCDEFGHIJK
```

### `insert()`

O método `insert()` é usado em combinação com StringBuilder para adicionar uma string num local específico. Segue-se um exemplo:

```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);
	}
}
```

Retorna o seguinte:

```java
AFGHIJKBCDEFGHIJK
```

Com o Integer (neste caso, 1), decide a posição em que a string deve ser inserida.

### `replace()`

O método `replace()` substitui uma string ou parte de uma string, definida por beginIndex e endIndex. Aqui está o exemplo correspondente:

```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);
	}
}
```

Retorna o seguinte:

```java
AFGHIJKE
```

### `reverse()`

Com o método `reverse()`, inverte completamente a string armazenada. Veja o exemplo a seguir:

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

Isto emite o seguinte:

```java
EDCBA
```

### `delete()`

Com o método `delete()` com StringBuilder em Java, pode apagar uma string inteira ou apenas uma parte, que também é delimitada com beginIndex e endIndex. Veja como é usado no exemplo:

```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);
	}
}
```

E devolve:

```java
AE
```

### `capacity()`

O método `capacity()` retorna o **número máximo de caracteres atuais** do StringBuilder do Java, que normalmente é 16. Se essa quantidade for excedida, segue-se a fórmula “Comprimento anterior dos caracteres \* 2 + 2”. Desta forma, se antes era 16, agora duplica-se (32) e soma-se 2 (32). Veja o exemplo a seguir:

```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());
	}
}
```

Os resultados agora são:

```java
16
16
34
```

### `ensureCapacity()`

O método `ensureCapacity()` garante que o **número de caracteres disponíveis corresponda, pelo menos, a um valor definido**. Caso contrário, a capacidade seguirá novamente a fórmula «Comprimento anterior dos caracteres \* 2 + 2». Consulte o exemplo:

```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());
	}
}
```

Assim, o programa retorna o seguinte:

```java
16
16
34
34
70
```

Primeiro, considerou-se o valor padrão (16) duas vezes, depois outras duas vezes o valor duplicado mais dois (34) e, por último, duplicou-se novamente o valor e somou-se dois (70).


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