0Pricing
Java Academy · Aula

StringBuilder para Concatenação Eficiente

Use StringBuilder para construir strings com eficiência dentro de laços e em formatações complexas.

StringBuilder para Concatenação Eficiente é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 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.

StringBuilder para concatenação eficiente

StringBuilder é uma alternativa mutável a String para construir texto de forma incremental. Ele evita a criação de muitos objetos String intermediários.

StringBuilder versus concatenação de String

Ao concatenar muitas strings, especialmente em laços, StringBuilder é consideravelmente mais rápido porque modifica um buffer interno de caracteres em vez de criar novos objetos.

// Inefficient: creates a new String every iteration
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i + ","; // 1000 new String objects!
}

// Efficient: StringBuilder uses a resizable char buffer
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(',');
}
String efficient = sb.toString(); // one final String created

API de StringBuilder

Principais métodos: append, insert, delete, replace, reverse, toString, comprimento, charAt, setCharAt.

StringBuilder sb = new StringBuilder("Hello");

sb.append(", World");     // Hello, World
sb.insert(5, "!");        // Hello!, World
sb.delete(5, 6);           // Hello, World
sb.replace(7, 12, "Java"); // Hello, Java
sb.reverse();               // avaJ ,olleH
sb.reverse();               // Hello, Java

System.out.println(sb);         // Hello, Java
System.out.println(sb.length()); // 11
System.out.println(sb.charAt(0)); // H

Encadeando chamadas de append

Todos os métodos append e os demais métodos de mutação retornam this, permitindo um encadeamento fluente.

StringBuilder html = new StringBuilder()
    .append("<div class=\"card\">")
    .append("<h2>").append("Product Title").append("</h2>")
    .append("<p>Price: $").append(String.format("%.2f", 29.99)).append("</p>")
    .append("<button>Add to Cart</button>")
    .append("</div>");

System.out.println(html.toString());

Capacidade inicial

Defina previamente o tamanho do StringBuilder com uma capacidade esperada para evitar o redimensionamento do vetor interno, melhorando o desempenho para strings grandes.

// Default capacity: 16 chars
StringBuilder small = new StringBuilder();

// Pre-sized: 10 items * ~50 chars each
StringBuilder report = new StringBuilder(500);

for (int i = 1; i <= 10; i++) {
    report.append(String.format("%-3d. Record %04d: processed OK%n", i, i));
}

System.out.println(report.toString().substring(0, 30));
// "  1. Record 0001: processed OK"

deleteCharAt e exclusões específicas

deleteCharAt remove um único caractere. delete(start, end) remove um intervalo. Essas operações são O(n) devido ao deslocamento do vetor.

StringBuilder sb = new StringBuilder("Hello, World!");

sb.deleteCharAt(5);     // removes comma: "Hello World!"
sb.delete(5, 6);         // removes space: "HelloWorld!"

System.out.println(sb); // HelloWorld!

// Replace to fix a typo
StringBuilder typo = new StringBuilder("Helo, Java!");
typo.replace(typo.indexOf("Helo"), typo.indexOf("Helo") + 4, "Hello");
System.out.println(typo); // Hello, Java!

Construindo CSV

Um padrão prático: construir uma linha CSV com StringBuilder e tratar corretamente os separadores.

import java.util.List;

static String toCsv(List<String> values) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < values.size(); i++) {
        if (i > 0) sb.append(',');
        sb.append(escapeCsv(values.get(i)));
    }
    return sb.toString();
}

static String escapeCsv(String s) {
    if (s.contains(",") || s.contains("\""))
        return "\"" + s.replace("\"", "\"\"") + "\"";
    return s;
}

System.out.println(toCsv(List.of("Alice", "Smith, Jr.", "30")));
// Alice,"Smith, Jr.",30

StringJoiner para saída separada por delimitadores

StringJoiner simplifica a união de elementos com um delimitador, um prefixo opcional e um sufixo opcional — não é necessário tratar os separadores manualmente.

import java.util.StringJoiner;

StringJoiner sj = new StringJoiner(", ", "[", "]");
sj.add("Alice");
sj.add("Bob");
sj.add("Charlie");
System.out.println(sj.toString()); // [Alice, Bob, Charlie]

// Equivalent with String.join
String joined = String.join(", ", "Alice", "Bob", "Charlie");
System.out.println(joined); // Alice, Bob, Charlie

// Streams: collect with joining collector
import java.util.stream.*;
List.of("a", "b", "c").stream()
    .collect(Collectors.joining(", ", "(", ")"));
// (a, b, c)

StringBuilder versus StringBuffer

StringBuffer é a versão sincronizada e segura para uso concorrente de StringBuilder. Ela é mais lenta devido ao bloqueio. Use StringBuilder em contextos de execução sem concorrência (99% dos casos).

// StringBuffer: thread-safe but slower (synchronized methods)
StringBuffer buf = new StringBuffer();
buf.append("Thread-safe");
buf.append(" but slow");

// StringBuilder: not thread-safe but faster
StringBuilder sb = new StringBuilder();
sb.append("Fast");
sb.append(" single-threaded");

// When to use StringBuffer:
// - Multiple threads write to the same buffer
// - Almost always a design smell — redesign to avoid sharing

Inversão e verificação de palíndromo

O método reverse() integrado ao StringBuilder torna elegante a verificação de palíndromos.

static boolean isPalindrome(String s) {
    String cleaned = s.toLowerCase()
        .replaceAll("[^a-z0-9]", ""); // remove non-alphanumeric
    String reversed = new StringBuilder(cleaned).reverse().toString();
    return cleaned.equals(reversed);
}

System.out.println(isPalindrome("A man, a plan, a canal: Panama")); // true
System.out.println(isPalindrome("race a car"));                      // false
System.out.println(isPalindrome("Was it a car or a cat I saw?"));    // true

No mundo real: construtor de consultas SQL

Construção de uma consulta SQL dinâmica usando StringBuilder, na qual as cláusulas WHERE são adicionadas condicionalmente.

static String buildQuery(String category, Double minPrice, Double maxPrice) {
    StringBuilder sql = new StringBuilder("SELECT * FROM products WHERE 1=1");
    if (category != null)
        sql.append(" AND category = '" + category + "'");
    if (minPrice != null)
        sql.append(" AND price >= ").append(minPrice);
    if (maxPrice != null)
        sql.append(" AND price <= ").append(maxPrice);
    sql.append(" ORDER BY name");
    return sql.toString();
}

System.out.println(buildQuery("Electronics", 50.0, null));
// SELECT * FROM products WHERE 1=1 AND category = 'Electronics' AND price >= 50.0 ORDER BY name

Verificação rápida

Por que a concatenação de strings com + é ineficiente em laços?

Recapitulação: StringBuilder para concatenação eficiente

Principais conclusões:

  • StringBuilder é mutável — append/insert/delete modificam um buffer interno
  • Use StringBuilder em laços para evitar a criação de strings em O(n²)
  • Todos os métodos de mutação retornam this, permitindo um encadeamento fluente
  • Defina previamente o tamanho do StringBuilder com a capacidade esperada para reduzir redimensionamentos internos
  • StringJoiner e String.join são convenientes para saídas separadas por delimitadores
  • StringBuffer é a alternativa sincronizada (segura para uso concorrente), porém mais lenta

Perguntas Frequentes

A aula “StringBuilder para Concatenação Eficiente” é grátis?

Sim — o texto completo de “StringBuilder para Concatenação Eficiente” é 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 para Concatenação Eficiente”?

Use StringBuilder para construir strings com eficiência dentro de laços e em formatações complexas. 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 2 de 4.

Quanto tempo leva a aula “StringBuilder para Concatenação Eficiente”?

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

  1. Imutabilidade de String e o Pool de Strings
  2. StringBuilder para Concatenação Eficiente
  3. Blocos de Texto e String.format
  4. Expressões Regulares com Pattern e Matcher
← Voltar para Java Academy