WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

StringBuilder: Kapazität, Momentaufnahmen und Wiederverwendung

Dimensioniere einen veränderlichen Textpuffer, sichere unveränderliche Ergebnisse und nutze pro Thread einen eigenen Puffer. Formatiere jedes Byte als zwei Hexziffern.

Version: Java SE 21

Syntax

StringBuilder(int capacity)
StringBuilder append(String str)
StringBuilder append(int i)
StringBuilder append(char c)
String toString()
void setLength(int newLength)
int length()       // StringBuilder and String
int capacity()     // StringBuilder

In Java SE 21 erzeugt StringBuilder(int) aus java.lang einen leeren Puffer: length() ist zunächst 0, und capacity() gibt die anfängliche Kapazität in UTF-16-Codeeinheiten an. Die Kapazität begrenzt die Länge nicht; bei Bedarf wächst der Puffer. Eine negative Kapazität löst eine NegativeArraySizeException aus.

append(String) hängt Text an (bei null vom Typ String den Text null), append(int) die Dezimaldarstellung und append(char) eine Codeeinheit. Jeder dieser Aufrufe liefert denselben Puffer zurück, sodass sich die Aufrufe verketten lassen. toString() hält den aktuellen Inhalt als unveränderlichen String fest; spätere Änderungen am Puffer wirken sich darauf nicht aus.

setLength(0) leert den Puffer logisch, bevor append(...) und toString() das nächste Ergebnis erzeugen. Das ist weder eine Aufforderung, die Kapazität zu verkleinern, noch ein sicheres Löschen. Beim Kürzen bleibt der Präfix erhalten, beim Verlängern wird mit U+0000 aufgefüllt, und eine negative Länge löst eine IndexOutOfBoundsException aus. StringBuilder ist nicht threadsicher: Jeder Worker-Thread baut vier Zeilen in seinem eigenen Puffer, und der Hauptthread liest die fertigen Strings nach join().

Für Hex ohne Trennzeichen sind genau zwei Ziffern pro Byte nötig. Math.multiplyExact(bytes.length, 2) berechnet die Anfangskapazität und löst eine ArithmeticException aus, falls das Ergebnis nicht in einen int passt. Byte.toUnsignedInt liefert einen Wert von 0 bis 255; die oberen und unteren vier Bits wählen je eine Hexziffer in Kleinschreibung. String.length() zählt beim Ergebnis UTF-16-Codeeinheiten, nicht Eingabebytes.

Beispiele

public class BuilderDemo {
    private static final String HEX = "0123456789abcdef";

    private static void writeRows(String worker, String[] rows) {
        StringBuilder line = new StringBuilder(8);
        for (int i = 0; i < rows.length; i++) {
            line.setLength(0);
            rows[i] = line.append(worker).append(":").append(i + 1).toString();
        }
    }

    private static String toHex(byte[] bytes) {
        StringBuilder hex = new StringBuilder(Math.multiplyExact(bytes.length, 2));
        for (byte b : bytes) {
            int value = Byte.toUnsignedInt(b);
            hex.append(HEX.charAt(value >>> 4));
            hex.append(HEX.charAt(value & 0x0f));
        }
        return hex.toString();
    }

    public static void main(String[] args) throws InterruptedException {
        String[] aRows = new String[4];
        String[] bRows = new String[4];
        Thread a = new Thread(() -> writeRows("A", aRows));
        Thread b = new Thread(() -> writeRows("B", bRows));
        a.start();
        b.start();
        a.join();
        b.join();

        for (String row : aRows) System.out.println(row);
        for (String row : bRows) System.out.println(row);
        String hex = toHex(new byte[] {0x00, 0x0f, (byte) 0xa5, (byte) 0xff});
        System.out.println("hex=" + hex + ", length=" + hex.length());
    }
}

Ergebnis

A:1
A:2
A:3
A:4
B:1
B:2
B:3
B:4
hex=000fa5ff, length=8

Jeder Worker-Thread verwendet denselben eigenen Puffer für vier Zeilen. Nach `join()` gibt der Hauptthread zuerst die Zeilen von A und dann die von B aus, unabhängig von der Ausführungsreihenfolge. Vier Bytes ergeben `000fa5ff` mit der Länge `8`.

Zugehörige Lektionen

  • Java · Lektion 28 · Fortgeschritten · Version: 2
  • Java · Lektion 35 · Fortgeschritten · Version: 2
  • Java · Lektion 62 · Fortgeschritten · Version: 2

Quellen