Como usar StringBuilder em Java

A classe StringBuilder em Java pode ser usada para substituir strings tradicionais em situações que demandam maior eficiência. Ao contrário de strings tradicionais, contudo, a classe StringBuilder permite que uma string seja alterada diretamente, sem a criação de um novo objeto. As mudanças podem ser feitas de forma eficiente, por diferentes métodos, para que o código seja otimizado.

O que é StringBuilder em Java?

A classe string em Java é imutável e não apresenta nenhuma subclasse, o que limita sua flexibilidade. Uma alternativa a ela é a classe StringBuilder em Java, que produz uma sequência de caracteres que podem ser alterados depois de serem criados. Dessa forma, StringBuilder em Java é parecida com StringBuffer. As duas classes têm finalidades semelhantes, no entanto, ao contrário de StringBuffer, StringBuilder não é sincronizada. Isso faz dela uma boa escolha para se trabalhar com threads únicas, por ser muito mais rápida e eficiente. Neste tutorial, apresentaremos a classe StringBuilder em Java e mostraremos suas diversas possibilidades de uso, por meio de exemplos de código.

Sintaxe de StringBuilder em Java

A sintaxe da classe StringBuilder em Java segue sempre o mesmo padrão, que tem a seguinte estrutura:

public final class StringBuilder
	extends Object
		implements Serializable, CharSequence

Para que você entenda o funcionamento básico da classe StringBuilder em Java e a finalidade dela, vamos analisar, primeiramente, a classe String tradicional. Depois de declarar um objeto em uma String, você não conseguirá mais alterá-lo. Assim, se você desejar realizar mudanças, terá de criar e salvar um objeto totalmente novo. Isso resultará no desperdício de dados e pode, até mesmo, ocasionar uma queda de desempenho. Por outro lado, se você optar por usar a classe StringBuilder em Java, poderá alterar strings sem precisar criar um novo objeto. Assim, o desperdício de dados será menor e o desempenho do seu código melhorará.

Quais construtores podem ser usados com StringBuilder em Java?

Quatro construtores que ajudam a converter a string no formato certo para a classe podem ser usados com a classe StringBuilder em Java, assim como nas configurações correspondentes. Estes são os quatro construtores de StringBuilder em Java e a finalidade de cada um:

• StringBuilder(): Gera uma StringBuilder vazia com capacidade máxima de 16 caracteres.
• StringBuilder(int capacity): Cria uma StringBuilder sem caracteres, cuja capacidade máxima é definida usando o argumento de capacidade.
• StringBuilder(CharSequence seq): Gera uma StringBuilder com os mesmos caracteres da sequência de caracteres armazenada.
• StringBuilder(String str): Cria uma StringBuilder com a string inserida.

Observe, agora, um exemplo de aplicação. Ele pode ajudar você a entender como esses construtores funcionam na prática:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
	str.append("ABC");
	System.out.println("Primeiro construtor  = " + str.toString());
	StringBuilder str2 = new StringBuilder(5);
	System.out.println("Segundo construtor  = " + str2.capacity());
	StringBuilder str3 = new StringBuilder("ABCDEFGHIJK");
	System.out.println("Terceiro construtor = " + str3.toString());
	StringBuilder str4 = new StringBuilder(str3.toString());
	System.out.println("Quarto construtor = " + str4.toString());
	}
}

Ao usarmos o comando Java System.out.println para obtermos o resultado, obtemos a seguinte saída:

Primeiro construtor = ABC
Segundo construtor = 5
Terceiro construtor = ABCDEFGHIJK
Quarto construtor = ABCDEFGHIJK

Métodos de StringBuilder em Java

Existem diversos métodos que podem ser usados com a classe StringBuilder em Java. Abaixo, apresentamos os mais importantes deles, assim como exemplos de código ilustrando a aplicação.

append()

O método append() é usado para adicionar uma string à outra. Ele contém vários parâmetros. Veja seu funcionamento na prática:

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

Este será o resultado apresentado:

ABCDEFGHIJK

insert()

O método insert() é usado em combinação com StringBuilder em Java para inserir uma string em um ponto específico. Veja um exemplo de como ele funciona:

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

Este será o resultado apresentado:

AFGHIJKBCDEFGHIJK

O inteiro (nesse caso, 1) é usada para definir a posição em que a string será inserida.

replace()

O método replace() substitui uma string ou parte dela. Ele é definido usando os parâmetros beginIndex e endIndex. Na prática, o método funciona assim:

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

O resultado será o seguinte:

AFGHIJKE

reverse()

O método reverse() é usado para inverter a ordem da string armazenada. Ele funciona da seguinte forma:

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

Este será o resultado apresentado:

EDCBA

delete()

O método delete() com StringBuilder em Java serve para excluir uma string inteira ou parte dela. Se você quiser remover apenas uma parte da string, use os parâmetros beginIndex e endIndex.

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.delete(1,4);
	System.out.println(str);
	}
}

Este será o resultado apresentado:

AE

capacity()

O método capacity() informa a atual contagem máxima de caracteres para a classe StringBuilder. O valor padrão costuma ser 16. Para aumentá-lo, o usuário pode aplicar a fórmula “contagem de caracteres atual * 2 + 2”. Portanto, se a contagem atual for 16, ela será multiplicada por dois (32) e somada a dois (34). Veja o exemplo abaixo para entender seu funcionamento:

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("Um exemplo diferente");
	System.out.println(str.capacity());
	}
}

Este será o resultado:

16
16
34

ensureCapacity()

O método ensureCapacity() assegura que o número de caracteres disponíveis seja, pelo menos, igual ao valor definido. Se isso não for verdade, a capacidade será aumentada usando a fórmula citada anteriormente “contagem de caracteres atual * 2 + 2”. Veja seu funcionamento no exemplo a seguir:

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("Um exemplo diferente");
	System.out.println(str.capacity());
	str.ensureCapacity(5);
	System.out.println(str.capacity());
	str.ensureCapacity(40);
	System.out.println(str.capacity());
	}
}

Este será o resultado:

16
16
34
34
70

Primeiro, temos o valor padrão (16). Em seguida, ele é multiplicado por dois e somado a dois (34). Por fim, o novo valor também é multiplicado por dois e somado a dois (70).