Como usar String­Buil­der em Java

A classe String­Buil­der em Java pode ser usada para subs­ti­tuir strings tra­di­ci­o­nais em situações que demandam maior efi­ci­ên­cia. Ao contrário de strings tra­di­ci­o­nais, contudo, a classe String­Buil­der permite que uma string seja alterada di­re­ta­mente, sem a criação de um novo objeto. As mudanças podem ser feitas de forma eficiente, por di­fe­ren­tes métodos, para que o código seja otimizado.

O que é String­Buil­der em Java?

A classe string em Java é imutável e não apresenta nenhuma subclasse, o que limita sua fle­xi­bi­li­dade. Uma al­ter­na­tiva a ela é a classe String­Buil­der em Java, que produz uma sequência de ca­rac­te­res que podem ser alterados depois de serem criados. Dessa forma, String­Buil­der em Java é parecida com String­Buf­fer. As duas classes têm fi­na­li­da­des se­me­lhan­tes, no entanto, ao contrário de String­Buf­fer, String­Buil­der não é sin­cro­ni­zada. Isso faz dela uma boa escolha para se trabalhar com threads únicas, por ser muito mais rápida e eficiente. Neste tutorial, apre­sen­ta­re­mos a classe String­Buil­der em Java e mos­tra­re­mos suas diversas pos­si­bi­li­da­des de uso, por meio de exemplos de código.

Sintaxe de String­Buil­der em Java

A sintaxe da classe String­Buil­der 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 fun­ci­o­na­mento básico da classe String­Buil­der em Java e a fi­na­li­dade dela, vamos analisar, pri­mei­ra­mente, a classe String tra­di­ci­o­nal. Depois de declarar um objeto em uma String, você não con­se­guirá mais alterá-lo. Assim, se você desejar realizar mudanças, terá de criar e salvar um objeto to­tal­mente novo. Isso resultará no des­per­dí­cio de dados e pode, até mesmo, ocasionar uma queda de de­sem­pe­nho. Por outro lado, se você optar por usar a classe String­Buil­der em Java, poderá alterar strings sem precisar criar um novo objeto. Assim, o des­per­dí­cio de dados será menor e o de­sem­pe­nho do seu código melhorará.

Quais cons­tru­to­res podem ser usados com String­Buil­der em Java?

Quatro cons­tru­to­res que ajudam a converter a string no formato certo para a classe podem ser usados com a classe String­Buil­der em Java, assim como nas con­fi­gu­ra­ções cor­res­pon­den­tes. Estes são os quatro cons­tru­to­res de String­Buil­der em Java e a fi­na­li­dade de cada um:

• StringBuilder(): Gera uma String­Buil­der vazia com ca­pa­ci­dade máxima de 16 ca­rac­te­res.
• StringBuilder(int capacity): Cria uma String­Buil­der sem ca­rac­te­res, cuja ca­pa­ci­dade máxima é definida usando o argumento de ca­pa­ci­dade.
• StringBuilder(CharSequence seq): Gera uma String­Buil­der com os mesmos ca­rac­te­res da sequência de ca­rac­te­res ar­ma­ze­nada.
• StringBuilder(String str): Cria uma String­Buil­der com a string inserida.

Observe, agora, um exemplo de aplicação. Ele pode ajudar você a entender como esses cons­tru­to­res 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 String­Buil­der em Java

Existem diversos métodos que podem ser usados com a classe String­Buil­der em Java. Abaixo, apre­sen­ta­mos os mais im­por­tan­tes deles, assim como exemplos de código ilus­trando a aplicação.

append()

O método append() é usado para adicionar uma string à outra. Ele contém vários pa­râ­me­tros. Veja seu fun­ci­o­na­mento 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 apre­sen­tado:

ABCDEFGHIJK

insert()

O método insert() é usado em com­bi­na­ção com String­Buil­der em Java para inserir uma string em um ponto es­pe­cí­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 apre­sen­tado:

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 pa­râ­me­tros 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 ar­ma­ze­nada. 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 apre­sen­tado:

EDCBA

delete()

O método delete() com String­Buil­der em Java serve para excluir uma string inteira ou parte dela. Se você quiser remover apenas uma parte da string, use os pa­râ­me­tros 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 apre­sen­tado:

AE

capacity()

O método capacity() informa a atual contagem máxima de ca­rac­te­res para a classe String­Buil­der. O valor padrão costuma ser 16. Para aumentá-lo, o usuário pode aplicar a fórmula “contagem de ca­rac­te­res atual * 2 + 2”. Portanto, se a contagem atual for 16, ela será mul­ti­pli­cada por dois (32) e somada a dois (34). Veja o exemplo abaixo para entender seu fun­ci­o­na­mento:

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 ca­rac­te­res dis­po­ní­veis seja, pelo menos, igual ao valor definido. Se isso não for verdade, a ca­pa­ci­dade será aumentada usando a fórmula citada an­te­ri­or­mente “contagem de ca­rac­te­res atual * 2 + 2”. Veja seu fun­ci­o­na­mento 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 é mul­ti­pli­cado por dois e somado a dois (34). Por fim, o novo valor também é mul­ti­pli­cado por dois e somado a dois (70).