Java Academy · Lektion

Varför strängar är oföränderliga

Förstå strängars oföränderlighet

Lektion 1 av 413 steg

Varför strängar är oföränderliga är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Strängar kan inte ändras

I Java är en String oföränderlig: när den har skapats kan dess tecken aldrig ändras. Alla metoder som verkar ändra en sträng returnerar i själva verket en helt ny sträng.

Metoder returnerar nya strängar

toUpperCase(), replace() och liknande metoder ändrar inte originalet. De skapar en ny String och lämnar originalet orört.

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

Omplacering är inte ändring

När du skriver s = s + "!" pekar variabeln nu på en ny sträng. Det gamla strängobjektet är oförändrat och kan samlas in av skräpsamlaren.

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

Varför oföränderlighet?

Oföränderlighet ger verkliga fördelar:

Trådsäkerhet: strängar kan delas utan lås
Cachning: hashkoder och poster i poolen förblir giltiga
Säkerhet: en sträng som skickas till en metod kan inte ändras utan att du märker det

String-poolen

Identiska strängliteraler kan dela på samma objekt i strängpoolen. Det är bara säkert eftersom strängar aldrig ändras. Här hänvisar två literaler till samma objekt i poolen.

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 bryter poolningen

Om du använder new String(...) tvingas ett separat objekt fram, så referensjämförelsen ger olika resultat även om innehållet stämmer överens. Jämför alltid innehållet med 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));
    }
}

Kostnaden för konkatenering

Varje + på strängar skapar ett nytt objekt. Om du gör detta i en loop skapas många kortlivade strängar, vilket slösar tid och minne.

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

Kvadratisk tillväxt

Eftersom varje konkatenering kopierar alla tidigare tecken skalar det dåligt att bygga en lång sträng med + i en loop, ungefär O(n²). Det här är det grundläggande prestandaproblemet.

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

Oföränderliga värden är förutsägbara

Det är säkert att skicka en sträng till en metod: metoden kan inte ändra din kopia. Här bygger metoden en ny sträng och anroparens värde förblir oförändrat.

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

En förhandsvisning av lösningen

När du behöver bygga strängar effektivt tillhandahåller Java StringBuilder, en muterbar kompletterande klass. Den ändrar innehållet på plats i stället för att skapa nya objekt varje gång.

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

Jämförelse av de två metoderna

För några få konkateneringar är + helt lämpligt och lättläst. För många konkateneringar i en loop bör du föredra StringBuilder. Välj utifrån hur mycket text du behöver bygga.

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

Snabbtest

Vad händer egentligen när du anropar s.toUpperCase() på en String?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig varför strängar är oföränderliga:

Innehållet i en String ändras aldrig
Metoder returnerar nya strängar
Oföränderlighet möjliggör trådsäkerhet, poolning och säkerhet
Konkatenering med + i loopar skalar dåligt
StringBuilder är den muterbara lösningen

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Varför strängar är oföränderliga” gratis?

Ja – hela texten till ”Varför strängar är oföränderliga” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Varför strängar är oföränderliga”?

Förstå strängars oföränderlighet Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Varför strängar är oföränderliga”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy