O documento apresenta a classe StringBuilder em Java, destacando sua importância na manipulação eficiente de strings dinâmicas, evitando a criação de novas instâncias durante a concatenação. São discutidas suas características principais, métodos fundamentais, construtores e exemplos de uso. Além disso, o texto enfatiza a diferença entre String e StringBuilder, ressaltando o desempenho superior deste último.

1. Atenção, este é um post gratuito publicado no site da Devmedia e publicado no Slideshare
na conta da própria Devmedia. Sua republicação não é autorizada.
Para ler este e outros artigos de seu interesse, acesse http://www.devmedia.com.br
A Classe StringBuilder em Java
Veja neste artigo como trabalhar com a classe StringBuilder na linguagem Java, muito utilizada na
manipulação de objetos do tipo String, porém com mais flexibilidade e melhor desempenho.
Classe StringBuilder
A classe StringBuilder faz parte do pacote java.lang. Essa classe permite criar e manipular dados de Strings
dinamicamente, ou seja, podem criar variáveis de String modificáveis.
O significado da classe StringBuilder não tem o mesmo sentido que classe String. Existe uma diferença entre
essas classes, veja algumas características.
Características StringBuilder
o Armazena caracteres especificados pela sua capacidade, caso ela seja excedida, é aumentada para
acomodar os caracteres adicionais;
o Não precisa alocar novos objetos quando realiza uma concatenação;
o Não são sincronizadas;
o Não são seguras para threads;
Uma vantagem sobre a classe String é a concatenação de strings. Pois quando concatena strings com
StringBuilder é invocado o método append. Esse método aloca novas strings concatenadas para o mesmo
objeto, ou seja, cada vez que concatena strings não são criadas cópias dos objetos como é realizado pelo
método concat da classe String, contribuindo para um melhor desempenho do sistema.
Listagem 1: Concatenação de Strings com método append
1 public class TestaStringBuilder {
2 public static void main(String[] args) {
3
4 StringBuilder nomes = new StringBuilder();
5 nomes.append("Carlos>").append("Maria>").append("José>").append("Renata");
6
System.out.println(nomes.toString());
7

2. 8
9 }
10}
Figura 1: Ilustração gráfica do código da Listagem 1
Métodos StringBuilder
Abaixo são apresentados os métodos principais e mais utilizados.
length - Retorna o número de caracteres atualmente em um StringBuilder;
capacity – Retorna o número de caracteres que pode ser armazenado em um StringBuilder sem alocar mais
memória;
ensureCapacity – Garante que um StringBuilder tenha pelo menos a capacidade especificada;
setLength – Aumenta ou diminui o comprimento de uma StringBuilder;
charAt – Aceita um argumento inteiro que representa o índice e retorna o caractere nessa posição no
StringBuilder;
setCharAt – Copia caracteres de um StringBuilder no array de caracteres passado como um argumento, tendo
aceitação de até 4 argumentos;
o o índice inicial a partir do qual os caractere(s) devem ser copiados do StringBuilder;
o o índice um a mais do último caractere que será copiado a partir do StringBuilder;
o o array de caracteres para onde os caracteres serão copiados;
o localização inicial no array de caracteres em que o primeiro caractere deve ser colocado;

3. getChars – Retorna o caractere especificado;
reverse – Retorna os caracteres invertidos;
Listagem 2: Métodos capacity, ensureCapacity, setLength e length
1
public class Metodos_StringBuilder {
2
3
public static void main(String[] args) {
4
5
StringBuilder buffer = new StringBuilder("João Silveira Batista");
6
System.out.printf(" buffer = %sn tamanho = %dn capacidade (%d (tamanho) +
7
"16(valor inicial padrão)) = %dnn",
8 buffer.toString(),buffer.length(),buffer.length(),buffer.capacity())
9
10 //EXPANDE A CAPACIDADE P/ 75 CARACTERES
11 buffer.ensureCapacity(75);
12 System.out.printf("Nova Capacidade = %dnn", buffer.capacity());
13
14 //REDEFINE O TAMANHO, NÃO APARECENDO OS CARACTERES
// SE O ARGUMENTO FOR MENOR QUE A QUANTIDADE DE CARACTERES ORIGINAL
15
buffer.setLength(10);
16
System.out.printf("Novo tamanho = %dn buffer = %sn",buffer.length(),
17
buffer.toString());
18
}
19
}
20
Listagem 3: Métodos charAt, setChar e reverse
1 public class Metodos2_StringBuilder {
2
3 public static void main(String[] args) {

4. 4
5 StringBuilder buffer = new StringBuilder("Usando outros métodos StringBuilde
6
7 System.out.printf("buffer = %sn", buffer.toString());
System.out.printf("Caractere index 0: %snCaractere index 4: " +
8
"%snn",buffer.charAt(0),buffer.charAt(4));
9
10
char[] charArray = new char[buffer.length()];
11
12
buffer.getChars(0, buffer.length(), charArray, 0);
13
System.out.print("Os caracteres são: ");
14
15
for(char c : charArray)
16 System.out.print(c);
17
18 buffer.setCharAt(0, 'O');
19 buffer.setCharAt(4, 'P');
20
21 System.out.printf("nnbuffer = %s", buffer.toString());
22
buffer.reverse();
23
System.out.printf("nnbuffer = %sn", buffer.toString());
24
}
25
}
26
27
Construtores StringBuilder
Nessa classe existem quatro tipos de construtores que são apresentados abaixo, lembrando que quando é
declarado o construtor sem argumentos a capacidade inicial é identificada com 16 caracteres.
Listagem 4: Construtores

5. 1
public class Contrutores_StringBuilder {
2
public static void main(String[] args) {
3 StringBuilder buffer1 = new StringBuilder();
4 StringBuilder buffer2 = new StringBuilder(5655);
5 StringBuilder buffer3 = new StringBuilder("Texto Qualquer");
6
7 System.out.printf("buffer1 = "%s"n", buffer1.toString());
8 System.out.printf("buffer2 = "%s"n", buffer2.toString());
System.out.printf("buffer3 = "%s"n", buffer3.toString());
9
}
10
}
11
Método insert
Os métodos insert sobrecarregados inserem valores de vários tipos (primitivos, arrays de caracteres, Strings,
Objects e CharSequences) em qualquer posição de um StringBuilder.
Existem alguns cuidados nesses tipos de operação, pois se inserir um número maior que um comprimento da
StringBuilder ou menor que 0, irá estourar uma exceção StringIndexOutBoundsException.
Listagem 5: Método insert
public class StringBuilder_Insert {
1
public static void main(String[] args) {
2
Object objetoRef = "Maria";
3 String String = "Joaquina";
4 char[] conjArray = {'S','i','l','v','a'};
5
6 StringBuilder buffer = new StringBuilder();
7 buffer.insert(0, objetoRef);
8 buffer.insert(0, " ");
buffer.insert(0, String);
9
buffer.insert(0, " ");
10
buffer.insert(0, conjArray);
11
buffer.insert(0, " ");

6. 12
13 System.out.printf("Valores:n%snn", buffer.toString());
14 }
}
15
16
17
Método delete
Os métodos delete excluem caracteres em qualquer posição em um StringBuilder, aceitando 2 argumentos
sendo que um deles é o índice inicial e o índice a mais do fim dos caracteres a excluir. O
método deleteCharAt aceita um argumento que é o índice do caractere a excluir.
Listagem 6: Método delete
public class StringBuilder_Delete {
1
public static void main(String[] args) {
2
Object objetoRef = "Maria";
3
String String = "Joaquina";
4
char[] conjArray = {'S','i','l','v','a'};
5
6 StringBuilder buffer = new StringBuilder();
7
8 buffer.insert(0, objetoRef);
9 buffer.insert(0, " ");
10 buffer.insert(0, String);
11 buffer.insert(0, " ");
buffer.insert(0, conjArray);
12
buffer.insert(0, " ");
13
System.out.printf("Valores antes do delete:n%snn", buffer.toString());
14
15
buffer.delete(0, 2);
16
buffer.deleteCharAt(4);
17
System.out.printf("Valores depois do delete:n%snn", buffer.toString());

7. 18 }
19}
20
21
Para saber mais dos métodos acesse o link
: http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/StringBuilder.html.
Pessoal, espero que tenham gostado, para ver mais outros posts acessem esse link do meu
space: http://www.devmedia.com.br/ThiagoVaralloPalmeira.
Abraços e até a próxima!
Leia mais em: A Classe StringBuilder em Java http://www.devmedia.com.br/a-classe-stringbuilder-em-
java/25609#ixzz25gsvPSi9