Diferença entre String, StringBuilder e StringBuffer em Java #1

Nesse post irei explicar a diferença entre String, StringBuilder e StringBuffer.

Ainda existem dúvidas sobre o real motivo da existência desses tipos, por isso vou explicar e assim você será capaz de julgar com eficácia qual será usado em um momento adequado.

Em java todos os tipos utilizados, exceto os tipos primitivos (boolean, int, char e double), são "objetos". Ao contrário do que acontece em C e C++, string em Java não são tratados como sequência de caracteres terminadas por NULL. São objetos ou instâncias da classe java.lang.String, por isso devem ser declarados e instanciados.

EXEMPLO

Quando estamos codificando, as vezes é necessário concatenar strings, e usamos o operador "+" para faze-lo. No entanto o uso com frequência desse operador na sua aplicação lhe trará problemas assim você passará a dar mais importância ao uso do StringBuilder e StringBuffer.

Certamente já ouviram em algum lugar que "String são imutáveis", ou seja, você não pode mudar seu valor após a primeira atribuição. Mas, se strings são imutáveis como eu consigo concatenar vários valores a uma String, modificando-a para que se torne diferente da original?

O que acontece na verdade é que você não está concatenando nada, mas sim, criando um novo objeto em memória. Cada vez que você concatena (ou acha que esta concatenando) uma String com outra, você esta na verdade criando diversos objetos distindos em memória, e as Strings primárias perdem a referência, mas ainda não deixaram de existir, continuam lá. Vamos analisar esse exemplo parar ver o que acontece.

• Concatenação simples se String

public class ConcatenarString {
 public static void main (String[] args){ 
  // Criamos uma string e atribuimos um valor
  
  String str = "Hello"; 
  
  // Nossa string passará a ser: "Hello World".
  // No entanto a string "World" foi criada em memória,
  // Após a 'concatenação' a JVM cria um outro objeto "Hello World".
  // Totalizando 3 objetos para que essa 'concatenação' ocorra.
  
  str.concat(" World"); 
  
  // O mesmo conceito é aplicado aqui.
  // É criada uma string "from Java" em memória, depois é criada uma
  // nova juntando "Hello World from Java".
  // No total temos agora 5 objetos em memória,
  // sendo que estamos utilizando apenas 1,
  // veja que desperdício.  
  
  str += " from Java";
 }
}

E se isso ainda não te convenceu que usar a concatenação dessa forma é muito prejudicial a performance da aplicação, vamos verificar o seguinte teste.

• Concatenar 35536 vezes o literal "f"

public class ConcatenarString {
    public static void main(String[] args) {
        String strFinal = "";

        // Vamos concatenar 65536 vezes o caracter 'f', 
        // então entenda que cada vez que passarmos no laço 
        // a JVM irá criar um novo objeto em memória.
        for (int i = 0; i < 65536; i++) {
            strFinal += "f";
        }
    }
}

Veja quanto tempo demora para executar o código acima na sua máquina. Na minha máquina o tempo foi de 7 segundos.

Vou parando por aqui... enquanto aguarda a continuação desse post, realize novos testes alterando a quantidade de caracteres e verifique como fica o desempenho da sua máquina para processar o código.

Até mais, abraços!