Java Academy · Lektion

StringBuilder jämfört med StringBuffer

Avvägningar kring trådsäkerhet

Lektion 4 av 413 steg

StringBuilder jämfört med StringBuffer är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 4 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.

Två muterbara klasser

Java har två muterbara strängklasser: StringBuilder och StringBuffer. Deras API:er är nästan identiska, men de skiljer sig på ett avgörande sätt: trådsäkerhet.

Samma API

Båda klasserna erbjuder append, insert, delete, reverse och resten av metoderna. Kod som använder den ena kan vanligtvis byta till den andra genom att endast ändra typnamnet.

public class Main {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello").append(", ").append("World");
        System.out.println(sb);
    }
}

StringBuffer är synkroniserad

Metoderna i StringBuffer är synkroniserade, vilket innebär att flera trådar säkert kan ändra samma instans. Denna säkerhet medför en liten prestandakostnad.

public class Main {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("thread-safe");
        buffer.append("!");
        System.out.println(buffer);
    }
}

StringBuilder är inte synkroniserad

StringBuilder hoppar över synkronisering, vilket gör den snabbare. Nackdelen är att det inte är säkert att dela en instans mellan trådar utan extern samordning.

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("fast");
        builder.append("!");
        System.out.println(builder);
    }
}

När ska StringBuilder användas?

Använd StringBuilder i det vanliga fallet: när du bygger strängar inuti en enda metod eller tråd. Det är standardvalet i nästan all vardaglig kod.

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

När ska StringBuffer användas?

Välj StringBuffer endast när samma byggarinstans verkligen delas och ändras av flera trådar. Det är ovanligt i praktiken.

public class Main {
    public static void main(String[] args) {
        StringBuffer shared = new StringBuffer("log: ");
        shared.append("event A; ");
        shared.append("event B");
        System.out.println(shared);
    }
}

Lokala variabler delas inte

En builder som deklareras och används endast i en metod är aldrig synlig för andra trådar, så StringBuilder är alltid rätt där. Avsaknaden av synkronisering kan inte orsaka något problem.

public class Main {
    static String build() {
        StringBuilder sb = new StringBuilder();
        sb.append("local only");
        return sb.toString();
    }
    public static void main(String[] args) {
        System.out.println(build());
    }
}

Prestandaskillnad

Synkroniseringskostnaden i StringBuffer gör den långsammare vid entrådad användning. I täta loopar ger StringBuilder bättre prestanda.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append('x');
        }
        System.out.println("Built length: " + sb.length());
    }
}

Historisk anmärkning

StringBuffer kom först, i den tidiga versionen av Java. StringBuilder lades till i Java 5 som ett osynkroniserat och snabbare alternativ för det vanliga entrådade fallet.

Välj rätt

Använd som standard StringBuilder. Byt endast till StringBuffer när Ni kan bevisa att en enda instans delas mellan trådar. Annars betalar Ni för säkerhet som Ni inte behöver.

public class Main {
    public static void main(String[] args) {
        StringBuilder result = new StringBuilder();
        result.append("Use StringBuilder ").append("by default");
        System.out.println(result);
    }
}

Båda konverterar till String

Båda klasserna skapar en oföränderlig String genom toString(). Valet mellan dem påverkar bara uppbyggnaden, inte slutresultatet.

public class Main {
    public static void main(String[] args) {
        String a = new StringBuilder("one").toString();
        String b = new StringBuffer("two").toString();
        System.out.println(a + " " + b);
    }
}

Snabbkontroll

Vad är den huvudsakliga skillnaden mellan StringBuilder och StringBuffer?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er avvägningarna:

Båda har nästan identiska API:er
StringBuffer är synkroniserad (trådsäker, långsammare)
StringBuilder är osynkroniserad (snabbare)
Använd som standard StringBuilder för entrådad uppbyggnad
Använd StringBuffer endast för instanser som verkligen delas

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 ”StringBuilder jämfört med StringBuffer” gratis?

Ja – hela texten till ”StringBuilder jämfört med StringBuffer” 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 ”StringBuilder jämfört med StringBuffer”?

Avvägningar kring trådsäkerhet 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 4 av 4.

Hur lång tid tar lektionen ”StringBuilder jämfört med StringBuffer”?

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