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

  • Armazena caracteres especificados pela sua capacidade, caso ela seja excedida, é aumentada para acomodar os caracteres adicionais;
  • Não precisa alocar novos objetos quando realiza uma concatenação;
  • Não são sincronizadas;
  • 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

public class TestaStringBuilder {
         public static void main(String[] args) {
		
	StringBuilder nomes = new StringBuilder();
		nomes.append("Carlos>").append("Maria>").append("José>").append("Renata");
		
	System.out.println(nomes.toString());
	
        }
}
Ilustração gráfica do código da Listagem 1

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 índice inicial a partir do qual os caractere(s) devem ser copiados do StringBuilder;
  • o índice um a mais do último caractere que será copiado a partir do StringBuilder;
  • o array de caracteres para onde os caracteres serão copiados;
  • localização inicial no array de caracteres em que o primeiro caractere deve ser colocado;

getChars – Retorna o caractere especificado;

reverse – Retorna os caracteres invertidos;

Listagem 2: Métodos capacity, ensureCapacity, setLength e length

public class Metodos_StringBuilder {

	public static void main(String[] args) {
		
	    StringBuilder buffer = new StringBuilder("João Silveira Batista");
	    System.out.printf(" buffer = %s\n tamanho = %d\n capacidade (%d (tamanho) + " +
				"16(valor inicial padrão)) = %d\n\n",
				buffer.toString(),buffer.length(),buffer.length(),buffer.capacity());
		
		//EXPANDE A CAPACIDADE P/ 75 CARACTERES
		buffer.ensureCapacity(75);
		System.out.printf("Nova Capacidade = %d\n\n", buffer.capacity());
		
		//REDEFINE O TAMANHO, NÃO APARECENDO OS CARACTERES 
		// SE O ARGUMENTO FOR MENOR QUE A QUANTIDADE DE CARACTERES ORIGINAL
		buffer.setLength(10);
		System.out.printf("Novo tamanho = %d\n buffer = %s\n",buffer.length(), 
				buffer.toString());
	}
}

Listagem 3: Métodos charAt, setChar e reverse

public class Metodos2_StringBuilder {

	public static void main(String[] args) {
		
		StringBuilder buffer = new StringBuilder("Usando outros métodos StringBuilder");
		
		System.out.printf("buffer = %s\n", buffer.toString());
		System.out.printf("Caractere index 0: %s\nCaractere index 4: " +
				"%s\n\n",buffer.charAt(0),buffer.charAt(4));
		
		char[] charArray = new char[buffer.length()];
		
		buffer.getChars(0, buffer.length(), charArray, 0);
		System.out.print("Os caracteres são: ");
		
		for(char c : charArray)
			System.out.print(c);
		
		buffer.setCharAt(0, 'O');
		buffer.setCharAt(4, 'P');
		
		System.out.printf("\n\nbuffer = %s", buffer.toString());
		
		buffer.reverse();
		System.out.printf("\n\nbuffer = %s\n", buffer.toString());
	}
}

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

public class Contrutores_StringBuilder {
	public static void main(String[] args) {
		StringBuilder buffer1 = new StringBuilder();
		StringBuilder buffer2 = new StringBuilder(5655);
		StringBuilder buffer3 = new StringBuilder("Texto Qualquer");
		
		System.out.printf("buffer1 = \"%s\"\n", buffer1.toString());
		System.out.printf("buffer2 = \"%s\"\n", buffer2.toString());
		System.out.printf("buffer3 = \"%s\"\n", buffer3.toString());
	}
}

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 {
	public static void main(String[] args) {	
		Object objetoRef = "Maria";
		String String = "Joaquina";
		char[] conjArray = {'S','i','l','v','a'};

		StringBuilder buffer = new StringBuilder();	
		buffer.insert(0, objetoRef);
		buffer.insert(0, " ");
		buffer.insert(0, String);
		buffer.insert(0, " ");
		buffer.insert(0, conjArray);
		buffer.insert(0, " ");
		
		System.out.printf("Valores:\n%s\n\n", buffer.toString());	
	}
}

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 {
	public static void main(String[] args) {	
		Object objetoRef = "Maria";
		String String = "Joaquina";
		char[] conjArray = {'S','i','l','v','a'};
		
		StringBuilder buffer = new StringBuilder();
		
		buffer.insert(0, objetoRef);
		buffer.insert(0, " ");
		buffer.insert(0, String);
		buffer.insert(0, " ");
		buffer.insert(0, conjArray);
		buffer.insert(0, " ");	
		System.out.printf("Valores antes do delete:\n%s\n\n", buffer.toString());	
		
		buffer.delete(0, 2);
		buffer.deleteCharAt(4);	
		System.out.printf("Valores depois do delete:\n%s\n\n", buffer.toString());
	}
}

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!