Java Academy · Aula

Por que as Cadeias são Imutáveis

Entenda a imutabilidade das cadeias

Por que as Cadeias são Imutáveis é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 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.

As cadeias de caracteres não podem mudar

Em Java, uma String é imutável: depois de criada, seus caracteres nunca podem mudar. Qualquer método que pareça modificar uma cadeia de caracteres, na verdade, retorna uma cadeia completamente nova.

Os métodos retornam novas cadeias de caracteres

toUpperCase(), replace() e outros métodos semelhantes não alteram o original. Eles produzem uma nova String e deixam a original intacta.

public class Main {
    public static void main(String[] args) {
        String original = "hello";
        String upper = original.toUpperCase();
        System.out.println("original: " + original);
        System.out.println("upper: " + upper);
    }
}

Reatribuição não é mutação

Quando você escreve s = s + "!", a variável passa a apontar para uma nova cadeia de caracteres. O objeto de cadeia antigo permanece inalterado e pode ser coletado pelo coletor de lixo.

public class Main {
    public static void main(String[] args) {
        String s = "hi";
        String firstRef = s;
        s = s + "!";
        System.out.println("s: " + s);
        System.out.println("firstRef: " + firstRef);
    }
}

Por que usar imutabilidade?

A imutabilidade traz benefícios reais:

Segurança entre execuções concorrentes: as cadeias de caracteres podem ser compartilhadas sem bloqueios
Armazenamento em cache: os códigos hash e as entradas do conjunto compartilhado permanecem válidos
Segurança: uma cadeia de caracteres passada a um método não pode ser alterada sem que você perceba

O conjunto compartilhado de cadeias de caracteres

Literais de cadeia de caracteres idênticos podem compartilhar um único objeto no conjunto compartilhado de cadeias de caracteres. Isso só é seguro porque as cadeias nunca mudam. Aqui, dois literais fazem referência ao mesmo objeto compartilhado.

public class Main {
    public static void main(String[] args) {
        String a = "java";
        String b = "java";
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}

new String interrompe o compartilhamento

Usar new String(...) força a criação de um objeto separado, portanto a igualdade de referências é diferente, mesmo que o conteúdo seja igual. Sempre compare o conteúdo com equals.

public class Main {
    public static void main(String[] args) {
        String a = "java";
        String b = new String("java");
        System.out.println("== : " + (a == b));
        System.out.println("equals: " + a.equals(b));
    }
}

O custo da concatenação

Cada + aplicado a cadeias de caracteres cria um objeto novo. Fazer isso em um laço aloca muitas cadeias de curta duração, desperdiçando tempo e memória.

public class Main {
    public static void main(String[] args) {
        String result = "";
        for (int i = 1; i <= 5; i++) {
            result = result + i;
        }
        System.out.println(result);
    }
}

Crescimento quadrático

Como cada concatenação copia todos os caracteres anteriores, criar uma cadeia longa com + em um laço não escala bem (aproximadamente O(n ao quadrado)). Esse é o principal problema de desempenho.

public class Main {
    public static void main(String[] args) {
        String s = "";
        for (int i = 0; i < 1000; i++) {
            s += "x";
        }
        System.out.println("Length: " + s.length());
    }
}

Valores imutáveis são previsíveis

Passar uma cadeia de caracteres a um método é seguro: o método não pode alterar a sua cópia. Aqui, o método cria uma nova cadeia e o valor de quem o chamou permanece intacto.

public class Main {
    static void shout(String s) {
        s = s + "!!!";
        System.out.println("inside: " + s);
    }
    public static void main(String[] args) {
        String msg = "hello";
        shout(msg);
        System.out.println("outside: " + msg);
    }
}

Prévia da solução

Quando você precisa criar cadeias de caracteres com eficiência, Java fornece StringBuilder, uma classe companheira mutável. Ela altera o conteúdo no próprio objeto, em vez de alocar novos objetos a cada vez.

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

Comparando as duas abordagens

Para algumas concatenações, + é perfeitamente adequado e legível. Para muitas concatenações em um laço, prefira StringBuilder. Escolha com base na quantidade de texto que você precisa construir.

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

Verificação rápida

O que realmente acontece quando você chama s.toUpperCase() em uma String?

Recapitulação

Você aprendeu por que as cadeias de caracteres são imutáveis:

O conteúdo de uma String nunca muda
Os métodos retornam cadeias de caracteres novas
A imutabilidade permite segurança entre execuções concorrentes, compartilhamento e segurança
Concatenar com + em laços não escala bem
StringBuilder é a solução mutável

Perguntas Frequentes

A aula “Por que as Cadeias são Imutáveis” é grátis?

Sim — o texto completo de “Por que as Cadeias são Imutáveis” é 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 “Por que as Cadeias são Imutáveis”?

Entenda a imutabilidade das cadeias 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 1 de 4.

Quanto tempo leva a aula “Por que as Cadeias são Imutáveis”?

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