0Pricing
Java Academy · Lezione

Perché le stringhe sono immutabili

Comprenda l'immutabilità delle stringhe

Perché le stringhe sono immutabili è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Le stringhe non possono cambiare

In Java, una String è immutabile: una volta creata, i suoi caratteri non possono mai cambiare. Qualsiasi metodo che sembra modificare una stringa restituisce in realtà una stringa completamente nuova.

I metodi restituiscono nuove stringhe

toUpperCase(), replace() e metodi simili non modificano l'originale. Producono una nuova String e lasciano intatta quella originale.

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 riassegnazione non è una mutazione

Quando si scrive s = s + "!", la variabile ora fa riferimento a una nuova stringa. Il vecchio oggetto stringa rimane invariato e può essere raccolto dal garbage collector.

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

Perché l'immutabilità?

L'immutabilità offre vantaggi concreti:

  • Sicurezza dei thread: le stringhe possono essere condivise senza blocchi
  • Memorizzazione nella cache: i codici hash e le voci del pool rimangono validi
  • Sicurezza: una stringa passata a un metodo non può essere modificata senza che ve ne accorgiate

Il pool delle stringhe

Valori letterali di stringa identici possono condividere un unico oggetto nel pool delle stringhe. Questo è sicuro solo perché le stringhe non cambiano mai. Qui due valori letterali fanno riferimento allo stesso oggetto nel pool.

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 il pooling

L'utilizzo di new String(...) forza la creazione di un oggetto separato, quindi l'uguaglianza dei riferimenti è diversa anche se i contenuti coincidono. Confronti sempre i contenuti con 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));
    }
}

Il costo della concatenazione

Ogni + applicato alle stringhe crea un nuovo oggetto. Farlo in un ciclo alloca molte stringhe di breve durata, sprecando tempo e memoria.

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

Crescita quadratica

Poiché ogni concatenazione copia tutti i caratteri precedenti, creare una stringa lunga con + in un ciclo ha una scarsa scalabilità, all'incirca O(n al quadrato). Questo è il problema principale in termini di prestazioni.

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

I valori immutabili sono prevedibili

Passare una stringa a un metodo è sicuro: il metodo non può modificare la vostra copia. Qui il metodo crea una nuova stringa e il valore del chiamante rimane intatto.

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

Anteprima della soluzione

Quando serve creare stringhe in modo efficiente, Java mette a disposizione StringBuilder, una classe complementare mutabile. Modifica il contenuto sul posto invece di allocare ogni volta nuovi oggetti.

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

Confronto tra i due approcci

Per poche concatenazioni, + va benissimo ed è leggibile. Per molte concatenazioni all'interno di un ciclo, è preferibile StringBuilder. La scelta dipende dalla quantità di testo da creare.

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 rapida

Che cosa succede realmente quando si chiama s.toUpperCase() su una String?

Riepilogo

È stato appreso perché le stringhe sono immutabili:

  • Il contenuto di una String non cambia mai
  • I metodi restituiscono stringhe nuove
  • L'immutabilità garantisce sicurezza dei thread, pooling e sicurezza
  • La concatenazione con + nei cicli ha una scarsa scalabilità
  • StringBuilder è la soluzione mutabile

Domande Frequenti

La lezione «Perché le stringhe sono immutabili» è gratuita?

Sì — il testo completo di «Perché le stringhe sono immutabili» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Perché le stringhe sono immutabili»?

Comprenda l'immutabilità delle stringhe Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Perché le stringhe sono immutabili»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Perché le stringhe sono immutabili
  2. Creare stringhe con StringBuilder
  3. Metodi di StringBuilder
  4. StringBuilder e StringBuffer a confronto
← Torna a Java Academy