Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

StringBuilder: capacidade, resultados imutáveis e reutilização

Dimensiona um buffer de texto mutável, guarda resultados imutáveis e utiliza um buffer por thread. Formata cada byte com dois algarismos hexadecimais.

Versão: Java SE 21

Sintaxe

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

Em Java SE 21, StringBuilder(int), do pacote java.lang, cria um buffer vazio: length() começa em 0 e capacity() indica a capacidade inicial em unidades de código UTF-16. A capacidade não limita o comprimento: o buffer cresce quando necessário. Uma capacidade negativa lança NegativeArraySizeException.

append(String) acrescenta texto (um argumento null do tipo String acrescenta null), append(int) acrescenta a representação decimal e append(char) acrescenta uma unidade de código. Cada sobrecarga devolve o mesmo buffer, permitindo encadear chamadas. toString() regista o conteúdo atual numa String imutável que não é afetada por alterações posteriores ao buffer.

setLength(0) esvazia logicamente o buffer antes de criar o resultado seguinte com append(...) e toString(). Não é um pedido para reduzir a capacidade nem um método de apagamento seguro. Encurtar preserva o prefixo, alongar acrescenta U+0000 e um comprimento negativo lança IndexOutOfBoundsException. StringBuilder não é seguro para uso concorrente: cada thread de trabalho cria quatro linhas no seu próprio buffer e a thread principal lê as cadeias resultantes depois de join().

Em hexadecimal sem separadores, cada byte ocupa exatamente dois algarismos. Math.multiplyExact(bytes.length, 2) calcula a capacidade inicial e lança ArithmeticException se o resultado não couber num int. Byte.toUnsignedInt devolve um valor de 0 a 255; os quatro bits mais significativos e os quatro menos significativos selecionam um algarismo hexadecimal cada, com letras minúsculas. No resultado, String.length() conta unidades de código UTF-16, não bytes de entrada.

Exemplos

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

Resultado

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

Cada thread de trabalho reutiliza o seu buffer para quatro linhas. Depois de `join()`, a thread principal escreve primeiro as linhas de A e depois as de B, independentemente da ordem de execução. Os quatro bytes produzem `000fa5ff`, com comprimento `8`.

Lições relacionadas

  • Java · Lição 28 · Avançado · Versão: 2
  • Java · Lição 35 · Avançado · Versão: 2
  • Java · Lição 62 · Avançado · Versão: 2

Fontes