Java Academy · Leçon

Pourquoi les chaînes sont immuables

Comprendre l’immuabilité des chaînes

Leçon 1 sur 413 étapes

Pourquoi les chaînes sont immuables est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Les chaînes ne peuvent pas changer

En Java, un String est immuable : une fois créé, ses caractères ne peuvent jamais changer. Toute méthode qui semble modifier une chaîne renvoie en réalité une toute nouvelle chaîne.

Les méthodes renvoient de nouvelles chaînes

toUpperCase(), replace() et les méthodes similaires ne modifient pas l’original. Elles produisent un nouveau String et laissent l’original intact.

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);
    }
}

La réaffectation n’est pas une mutation

Lorsque vous écrivez s = s + "!", la variable pointe maintenant vers une nouvelle chaîne. L’ancien objet chaîne reste inchangé et peut être récupéré par le ramasse-miettes.

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);
    }
}

Pourquoi l’immuabilité ?

L’immuabilité présente de réels avantages :

Sécurité des fils d’exécution : les chaînes peuvent être partagées sans verrous
Mise en cache : les codes de hachage et les entrées du réservoir restent valides
Sécurité : une chaîne transmise à une méthode ne peut pas être modifiée à votre insu

Le réservoir de chaînes

Des littéraux de chaîne identiques peuvent partager un même objet dans le réservoir de chaînes. Cela n’est sûr que parce que les chaînes ne changent jamais. Ici, deux littéraux désignent le même objet du réservoir.

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 empêche le partage du réservoir

L’utilisation de new String(...) force la création d’un objet distinct : l’égalité des références diffère donc, même si les contenus sont identiques. Comparez toujours les contenus avec 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));
    }
}

Le coût de la concaténation

Chaque + appliqué à des chaînes crée un nouvel objet. Effectuer cette opération dans une boucle alloue de nombreuses chaînes de courte durée, ce qui gaspille du temps et de la mémoire.

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);
    }
}

Croissance quadratique

Comme chaque concaténation recopie tous les caractères précédents, construire une longue chaîne avec + dans une boucle évolue mal (environ O(n au carré)). C’est le principal problème de performances.

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());
    }
}

Les valeurs immuables sont prévisibles

Transmettre une chaîne à une méthode est sûr : la méthode ne peut pas modifier votre copie. Ici, la méthode construit une nouvelle chaîne et la valeur de l’appelant reste intacte.

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);
    }
}

Aperçu de la solution

Lorsque vous devez construire des chaînes efficacement, Java fournit StringBuilder, une classe modifiable complémentaire. Elle modifie le contenu sur place au lieu d’allouer de nouveaux objets à chaque fois.

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());
    }
}

Comparer les deux approches

Pour quelques concaténations, + convient parfaitement et reste lisible. Pour de nombreuses concaténations dans une boucle, préférez StringBuilder. Choisissez en fonction de la quantité de texte à construire.

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);
    }
}

Vérification rapide

Que se passe-t-il réellement lorsque vous appelez s.toUpperCase() sur un String ?

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez appris pourquoi les chaînes sont immuables :

Le contenu d’un String ne change jamais
Les méthodes renvoient de nouvelles chaînes
L’immuabilité garantit la sécurité des fils d’exécution, le partage du réservoir et la sécurité
La concaténation avec + dans des boucles évolue mal
StringBuilder est la solution modifiable

Gratuit pour commencer

Apprends Java avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 104
Leçons: 374

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Pourquoi les chaînes sont immuables » est-elle gratuite ?

Oui — le texte complet de « Pourquoi les chaînes sont immuables » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Pourquoi les chaînes sont immuables » ?

Comprendre l’immuabilité des chaînes Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Pourquoi les chaînes sont immuables » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Pourquoi les chaînes sont immuables
Construire des chaînes avec StringBuilder
Méthodes de StringBuilder
StringBuilder ou StringBuffer

← Retour à Java Academy