Java Academy · Les

StringBuilder versus StringBuffer

Afwegingen rond thread safety

Les 4 van 413 stappen

StringBuilder versus StringBuffer is een gratis Java Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

Twee veranderlijke klassen

Java heeft twee veranderlijke tekenreeks klassen: StringBuilder en StringBuffer. Hun API's zijn vrijwel identiek, maar ze verschillen op één cruciaal punt: threadveiligheid.

Dezelfde API

Beide klassen bieden append, insert, delete, reverse en de overige methoden. Code die de ene klasse gebruikt, kan meestal naar de andere worden omgezet door alleen de typenaam te wijzigen.

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

StringBuffer is gesynchroniseerd

De methoden van StringBuffer zijn gesynchroniseerd, wat betekent dat meerdere threads dezelfde instantie veilig kunnen wijzigen. Deze veiligheid brengt een kleine invloed op de prestaties met zich mee.

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

StringBuilder is niet gesynchroniseerd

StringBuilder slaat synchronisatie over en is daardoor sneller. De afweging is dat het niet veilig is om één instantie zonder externe coördinatie tussen threads te delen.

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

Wanneer gebruik je StringBuilder?

Gebruik StringBuilder in de gebruikelijke situatie: wanneer je tekenreeksen binnen één methode of thread opbouwt. Dit is de standaardkeuze voor vrijwel alle alledaagse code.

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

Wanneer gebruik je StringBuffer?

Kies alleen voor StringBuffer wanneer dezelfde opbouwbuffer daadwerkelijk door meerdere threads wordt gedeeld en gewijzigd. In de praktijk komt dit zelden voor.

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

Lokale variabelen worden niet gedeeld

Een builder die alleen binnen één methode wordt gedeclareerd en gebruikt, is nooit zichtbaar voor andere threads. Daarom is StringBuilder daar altijd correct. Het ontbreken van synchronisatie kan geen probleem veroorzaken.

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

Prestatieverschil

De synchronisatie-overhead van StringBuffer maakt deze klasse trager bij gebruik met één thread. Voor strakke lussen levert StringBuilder betere prestaties.

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

Historische opmerking

StringBuffer kwam als eerste, in de beginjaren van Java. StringBuilder werd in Java 5 toegevoegd als het niet-gesynchroniseerde, snellere alternatief voor het veelvoorkomende geval met één thread.

De juiste keuze maken

Gebruik standaard StringBuilder. Stap alleen over op StringBuffer als je kunt aantonen dat één instantie tussen threads wordt gedeeld. Anders betaal je voor veiligheid die je niet nodig hebt.

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

Beide converteren naar String

Beide klassen leveren via toString() een onveranderlijke String op. De keuze tussen beide heeft alleen invloed op het opbouwen, niet op het uiteindelijke resultaat.

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

Korte toets

Wat is het belangrijkste verschil tussen StringBuilder en StringBuffer?

Beantwoord dit in de interactieve les

Samenvatting

Je hebt de afwegingen geleerd:

Beide hebben bijna identieke API's
StringBuffer is gesynchroniseerd (threadveilig, maar trager)
StringBuilder is niet-gesynchroniseerd (sneller)
Gebruik standaard StringBuilder voor opbouw met één thread
Gebruik StringBuffer alleen voor instanties die echt worden gedeeld

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “StringBuilder versus StringBuffer” gratis?

Ja — de volledige tekst van “StringBuilder versus StringBuffer” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “StringBuilder versus StringBuffer”?

Afwegingen rond thread safety Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “StringBuilder versus StringBuffer”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Java Academy