KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

StringBuilder: begincapaciteit, lengte en buffergroei

Maak onderscheid tussen buffercapaciteit en tekstlengte, schakel append-aanroepen aan elkaar en controleer de groei zonder een vaste eindcapaciteit te verwachten.

Versie: Java SE 21

Syntax

java.lang.StringBuilder
public StringBuilder()
public StringBuilder(int capacity)
public StringBuilder append(String str)
public StringBuilder append(int i)
public String toString()
public int capacity()
public int length()

In Java SE 21 bewaart java.lang.StringBuilder veranderbare tekst. StringBuilder() begint leeg met capaciteit 16; StringBuilder(int) begint leeg met precies de opgegeven capaciteit. Beide beginnen met lengte 0. Een negatieve capaciteit leidt tot een NegativeArraySizeException.

length() telt de opgeslagen UTF-16-code-eenheden (char-waarden), niet de Unicode-codepunten. capacity() geeft aan hoeveel code-eenheden er in totaal in de huidige buffer passen, inclusief de eenheden die er al in staan. Het is dus niet het aantal vrije plaatsen en ook geen grootte in bytes. Past de toegevoegde tekst niet, dan groeit de buffer automatisch.

append(String) voegt tekst toe aan het einde; een String-argument met de waarde null voegt "null" toe. append(int) voegt de decimale weergave van het getal toe, niet het teken met die code. Beide overbelastingen wijzigen hetzelfde object en geven het terug, zodat je aanroepen kunt aaneenschakelen.

toString() geeft een onveranderlijke String met de huidige tekst terug. Latere wijzigingen aan de builder veranderen dat resultaat niet. Kun je de uiteindelijke lengte schatten, dan kan een passende begincapaciteit het aantal herallocaties verminderen; die capaciteit begrenst de lengte niet.

Voorbeelden

public class Main {
    public static void main(String[] args) {
        StringBuilder defaults = new StringBuilder();
        StringBuilder text = new StringBuilder(4);

        System.out.println("default: capacity=" + defaults.capacity()
                + ", length=" + defaults.length());
        System.out.println("initial: capacity=" + text.capacity()
                + ", length=" + text.length());

        text.append("ID=").append(123);
        String result = text.toString();
        int length = text.length();
        if (text.capacity() < length) {
            throw new AssertionError("capacity < length");
        }

        System.out.println("text=" + result);
        System.out.println("length=" + length);
        System.out.println("capacity >= length: true");
    }
}

Resultaat

default: capacity=16, length=0
initial: capacity=4, length=0
text=ID=123
length=6
capacity >= length: true

Beide builders beginnen met lengte 0. De tweede begint met capaciteit precies 4. De aanroepen voegen `ID=` en `123` toe, en `toString()` geeft `ID=123` terug, met lengte 6. De buffer moest groeien; de controle vereist alleen `capacity() >= length()` en gaat niet uit van een specifieke capaciteit na de groei.

Gerelateerde lessen

  • Java · Les 49 · Gevorderd · Versie: 2

Bronnen