Java Academy · Aula

Construindo Cadeias com StringBuilder

Concatenação eficiente

Construindo Cadeias com StringBuilder é 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.

Um construtor mutável de cadeias de caracteres

StringBuilder é uma sequência mutável de caracteres. Diferentemente de String, você pode alterar seu conteúdo no próprio objeto, o que torna eficiente a criação de texto.

Criando um StringBuilder

Crie um com new StringBuilder() para obter um construtor vazio ou passe um texto inicial para começar com conteúdo.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        StringBuilder named = new StringBuilder("Hello");
        System.out.println("empty length: " + sb.length());
        System.out.println("named: " + named);
    }
}

Anexando texto

O método append adiciona conteúdo ao final. Ele aceita cadeias de caracteres, números, caracteres, valores booleanos e muito mais.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Count: ");
        sb.append(5);
        sb.append(' ');
        sb.append(true);
        System.out.println(sb);
    }
}

Encadeamento de métodos

append retorna o mesmo construtor, portanto as chamadas podem ser encadeadas de maneira fluida em uma única expressão.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("a").append("b").append("c").append(123);
        System.out.println(sb);
    }
}

Construindo em um laço

Este é o principal caso de uso. Faça o acréscimo dentro de um laço sem criar um novo objeto a cada vez e converta o resultado uma única vez no final.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 10; i++) {
            sb.append(i).append(' ');
        }
        System.out.println(sb.toString().trim());
    }
}

Convertendo em uma cadeia de caracteres

Chame toString() para obter uma String imutável comum do construtor quando terminar de modificá-lo.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("result");
        String finalText = sb.toString();
        System.out.println(finalText.toUpperCase());
    }
}

Unindo com um separador

Você pode criar listas separadas por vírgulas adicionando um separador entre os itens e tratando o último com cuidado.

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ann", "Ben", "Cara"};
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < names.length; i++) {
            sb.append(names[i]);
            if (i < names.length - 1) {
                sb.append(", ");
            }
        }
        System.out.println(sb);
    }
}

Lendo o comprimento

length() informa quantos caracteres o construtor contém no momento. Esse valor é atualizado conforme você usa append.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("12345");
        System.out.println("Length: " + sb.length());
    }
}

Acessando caracteres

Use charAt(index) para ler um único caractere por posição, assim como faria com uma String.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Coddy");
        System.out.println("First: " + sb.charAt(0));
        System.out.println("Last: " + sb.charAt(sb.length() - 1));
    }
}

Capacidade e comprimento

Um construtor mantém um buffer interno (capacidade) que cresce automaticamente. Você pode passar uma capacidade inicial para reduzir redimensionamentos quando souber o tamanho final.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(100);
        sb.append("short");
        System.out.println("Length: " + sb.length());
        System.out.println("Capacity at least: " + (sb.capacity() >= 100));
    }
}

Um construtor prático

Juntando tudo: crie uma pequena cadeia de caracteres de relatório com eficiência, usando chamadas encadeadas a append e um laço.

public class Main {
    public static void main(String[] args) {
        int[] sales = {100, 250, 75};
        StringBuilder report = new StringBuilder("Sales Report\n");
        int total = 0;
        for (int i = 0; i < sales.length; i++) {
            report.append("Day ").append(i + 1).append(": ").append(sales[i]).append('\n');
            total += sales[i];
        }
        report.append("Total: ").append(total);
        System.out.println(report);
    }
}

Verificação rápida

Por que StringBuilder é mais eficiente do que concatenações repetidas com + em um laço?

Recapitulação

Você aprendeu a criar cadeias de caracteres com StringBuilder:

É uma sequência de caracteres mutável
append adiciona conteúdo e permite o encadeamento
É ideal para criar texto em laços
Chame toString() para obter a String final
Uma capacidade inicial evita redimensionamentos

Perguntas Frequentes

A aula “Construindo Cadeias com StringBuilder” é grátis?

Sim — o texto completo de “Construindo Cadeias com StringBuilder” é 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 “Construindo Cadeias com StringBuilder”?

Concatenação eficiente 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 “Construindo Cadeias com StringBuilder”?

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