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() // StringBuilderEm 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