Java String­Buil­der: fun­ci­o­na­mento da classe mo­di­fi­cá­vel

A classe String­Buil­der do Java pode ser utilizada em vez de uma string tra­di­ci­o­nal. Ao contrário de uma string, esta classe permite fazer al­te­ra­ções di­re­ta­mente dentro da sequência de ca­rac­te­res. Estas mo­di­fi­ca­ções podem ser iniciadas a partir de di­fe­ren­tes métodos.

Java String­Buil­der como al­ter­na­tiva ao string clássico

A classe Strings do Java não pode ser mo­di­fi­cada e não tem sub­clas­ses. Uma al­ter­na­tiva a esta classe final no Java é o String­Buil­der, que cria uma sequência de ca­rac­te­res que pode ser mo­di­fi­cada após ser criada. Nesse sentido, o Java String­Buil­der é se­me­lhante ao String­Buf­fer, uma vez que ambas as classes de­sem­pe­nham uma tarefa se­me­lhante. No entanto, ao contrário do Buffer, o String­Buil­der não é sin­cro­ni­zado. Para trabalhar com um único thread, esta opção é es­pe­ci­al­mente re­co­men­dá­vel, pois permite trabalhar muito mais ra­pi­da­mente do que com a al­ter­na­tiva. Ex­pli­ca­mos o que é o String­Buil­der e quais as opções que esta classe oferece.

Sintaxe e usos

A sintaxe do String­Buil­der em Java segue sempre o mesmo padrão e tem a seguinte aparência:

public final class StringBuilder
	extends Object
		implements Serializable, CharSequence

Para entender realmente como essa classe funciona e qual é a sua fi­na­li­dade, convém primeiro dar uma olhada na classe string con­ven­ci­o­nal. Se um objeto for declarado em string, ele não poderá ser mo­di­fi­cado pos­te­ri­or­mente. Para fazer al­te­ra­ções, é ne­ces­sá­rio criar um objeto e guardá-lo com o valor mo­di­fi­cado. Isso gera resíduos de dados e pode pre­ju­di­car o de­sem­pe­nho. Por outro lado, se usar o String­Buil­der para a sua sequência de ca­rac­te­res, poderá modificá-la sem ter de criar uma nova string, reduzindo o des­per­dí­cio e me­lho­rando assim o de­sem­pe­nho.

Cons­tru­to­res da classe

A classe Java String­Buil­der possui quatro cons­tru­to­res que ajudam a converter a cadeia de ca­rac­te­res para o formato adequado para a classe. Eles também são uti­li­za­dos para con­fi­gu­ra­ção. A seguir, você verá os cons­tru­to­res e suas funções:

• StringBuilder(): gera um String­Buil­der vazio com uma ca­pa­ci­dade máxima de 16 ca­rac­te­res.
• StringBuilder(int capacity): cria um String­Buil­der sem ca­rac­te­res cuja quan­ti­dade máxima de ca­rac­te­res é definida pelo argumento “capacity”.
• StringBuilder(CharSequence seq): gera um String­Buil­der com os mesmos ca­rac­te­res que a sequência char ar­ma­ze­nada.
• StringBuilder(String str): cria um String­Buil­der com base nas strings ar­ma­ze­na­das.

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

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 comandoSystem.out.println, obterá o seguinte resultado:

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

Exemplos de métodos String­Buil­der em Java

Existem vários métodos para a classe Java String­Buil­der. Abaixo apre­sen­ta­mos alguns dos mais im­por­tan­tes com os frag­men­tos de código cor­res­pon­den­tes.

append()

O método append() é usado para adicionar uma string a outra. append() tem di­fe­ren­tes pa­râ­me­tros. Na prática, funciona da seguinte maneira:

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:

ABCDEFGHIJK

insert()

O método insert() é usado em com­bi­na­ção com String­Buil­der para adicionar uma string num local es­pe­cí­fico. Segue-se um exemplo:

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:

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 be­gi­nIn­dex e endIndex. Aqui está o exemplo cor­res­pon­dente:

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:

AFGHIJKE

reverse()

Com o método reverse(), inverte com­ple­ta­mente a string ar­ma­ze­nada. Veja o exemplo a seguir:

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:

EDCBA

delete()

Com o método delete() com String­Buil­der em Java, pode apagar uma string inteira ou apenas uma parte, que também é de­li­mi­tada com be­gi­nIn­dex e endIndex. Veja como é usado no exemplo:

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:

AE

capacity()

O método capacity() retorna o número máximo de ca­rac­te­res atuais do String­Buil­der do Java, que nor­mal­mente é 16. Se essa quan­ti­dade for excedida, segue-se a fórmula “Com­pri­mento anterior dos ca­rac­te­res * 2 + 2”. Desta forma, se antes era 16, agora duplica-se (32) e soma-se 2 (32). Veja o 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("Esto es otro ejemplo");
	System.out.println(str.capacity());
	}
}

Os re­sul­ta­dos agora são:

16
16
34

ensureCapacity()

O método ensureCapacity() garante que o número de ca­rac­te­res dis­po­ní­veis cor­res­ponda, pelo menos, a um valor definido. Caso contrário, a ca­pa­ci­dade seguirá novamente a fórmula «Com­pri­mento anterior dos ca­rac­te­res * 2 + 2». Consulte o exemplo:

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:

16
16
34
34
70

Primeiro, con­si­de­rou-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).