Java Academy · Aula

StringBuilder versus StringBuffer

Compromissos da segurança entre threads

StringBuilder versus StringBuffer é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Duas classes mutáveis

Java tem duas classes mutáveis de cadeias de caracteres: StringBuilder e StringBuffer. As interfaces de programação são quase idênticas, mas diferem em um aspecto crucial: segurança entre execuções concorrentes.

Mesma interface de programação

Ambas as classes oferecem append, insert, delete, reverse e os demais métodos. O código que usa uma geralmente pode mudar para a outra alterando apenas o nome do tipo.

public class Main {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello").append(", ").append("World");
        System.out.println(sb);
    }
}

StringBuffer é sincronizado

Os métodos de StringBuffer são sincronizados, o que significa que várias execuções concorrentes podem modificar com segurança a mesma instância. Essa segurança tem um pequeno custo de desempenho.

public class Main {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("thread-safe");
        buffer.append("!");
        System.out.println(buffer);
    }
}

StringBuilder não é sincronizado

StringBuilder dispensa a sincronização, tornando-se mais rápido. A desvantagem é que não é seguro compartilhar uma instância entre execuções concorrentes sem coordenação externa.

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("fast");
        builder.append("!");
        System.out.println(builder);
    }
}

Quando usar StringBuilder

Use StringBuilder no caso comum: ao criar cadeias de caracteres dentro de um único método ou em uma única execução concorrente. Essa é a escolha padrão para quase todo código cotidiano.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            sb.append("#");
        }
        System.out.println(sb);
    }
}

Quando usar StringBuffer

Use StringBuffer somente quando a mesma instância do construtor for realmente compartilhada e modificada por várias execuções concorrentes. Na prática, isso é raro.

public class Main {
    public static void main(String[] args) {
        StringBuffer shared = new StringBuffer("log: ");
        shared.append("event A; ");
        shared.append("event B");
        System.out.println(shared);
    }
}

Variáveis locais não são compartilhadas

Um objeto construtor declarado e usado somente dentro de um método nunca fica visível para outros fluxos de execução; portanto, StringBuilder está sempre correto nesse caso. A ausência de sincronização não pode causar problemas.

public class Main {
    static String build() {
        StringBuilder sb = new StringBuilder();
        sb.append("local only");
        return sb.toString();
    }
    public static void main(String[] args) {
        System.out.println(build());
    }
}

Diferença de desempenho

A sobrecarga de sincronização em StringBuffer faz com que ele seja mais lento em usos com um único fluxo de execução. Em laços intensivos, StringBuilder oferece melhor desempenho.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append('x');
        }
        System.out.println("Built length: " + sb.length());
    }
}

Nota histórica

StringBuffer surgiu primeiro, nos primórdios do Java. StringBuilder foi adicionado no Java 5 como a alternativa mais rápida e não sincronizada para o caso comum de uso com um único fluxo de execução.

Escolha correta

Use StringBuilder por padrão. Mude para StringBuffer somente quando puder provar que uma única instância é compartilhada entre fluxos de execução. Caso contrário, você pagará pelo custo de uma segurança de que não precisa.

public class Main {
    public static void main(String[] args) {
        StringBuilder result = new StringBuilder();
        result.append("Use StringBuilder ").append("by default");
        System.out.println(result);
    }
}

Ambos convertem para String

Qualquer uma das classes produz uma String imutável por meio de toString(). A escolha entre elas afeta apenas a construção, não o resultado final.

public class Main {
    public static void main(String[] args) {
        String a = new StringBuilder("one").toString();
        String b = new StringBuffer("two").toString();
        System.out.println(a + " " + b);
    }
}

Verificação rápida

Qual é a principal diferença entre StringBuilder e StringBuffer?

Recapitulação

Você aprendeu as diferenças:

Ambos têm interfaces de programação quase idênticas
StringBuffer é sincronizado (seguro para fluxos de execução, porém mais lento)
StringBuilder é não sincronizado (mais rápido)
Use StringBuilder por padrão para construções em um único fluxo de execução
Use StringBuffer somente para instâncias realmente compartilhadas

Perguntas Frequentes

A aula “StringBuilder versus StringBuffer” é grátis?

Sim — o texto completo de “StringBuilder versus StringBuffer” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “StringBuilder versus StringBuffer”?

Compromissos da segurança entre threads Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “StringBuilder versus StringBuffer”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy