CKTIS / Java
StringBuilder: capacidad, resultados inmutables y reutilización
Dimensiona un búfer de texto mutable, conserva resultados inmutables y asigna un búfer a cada hilo. Formatea cada byte con dos dígitos hexadecimales.
Versión: Java SE 21
Sintaxis
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() // StringBuilderEn Java SE 21, StringBuilder(int), de java.lang, crea un búfer vacío: length() empieza en 0 y capacity() indica la capacidad inicial en unidades de código UTF-16. La capacidad no limita la longitud: el búfer crece cuando hace falta. Una capacidad negativa lanza NegativeArraySizeException.
append(String) añade texto (si el argumento de tipo String es null, añade null), append(int) añade la representación decimal y append(char) añade una unidad de código. Cada sobrecarga devuelve el mismo búfer, lo que permite encadenar llamadas. toString() captura el contenido actual en un String inmutable que no cambia al modificar el búfer después.
setLength(0) vacía el contenido lógico del búfer antes de generar el siguiente resultado con append(...) y toString(). No solicita reducir la capacidad ni garantiza un borrado seguro. Acortar conserva el prefijo, alargar rellena con U+0000 y una longitud negativa lanza IndexOutOfBoundsException. StringBuilder no es seguro para el uso concurrente: cada hilo de trabajo genera cuatro líneas en su propio búfer y el hilo principal lee las cadenas resultantes después de join().
En hexadecimal sin separadores, cada byte ocupa exactamente dos dígitos. Math.multiplyExact(bytes.length, 2) calcula la capacidad inicial y lanza ArithmeticException si el resultado no cabe en un int. Byte.toUnsignedInt da un valor de 0 a 255; los cuatro bits altos y los cuatro bajos seleccionan un dígito hexadecimal en minúscula cada uno. String.length() cuenta las unidades de código UTF-16 del resultado, no los bytes de entrada.
Ejemplos
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 hilo de trabajo reutiliza su búfer para cuatro líneas. Tras `join()`, el hilo principal imprime primero las líneas de A y después las de B, con independencia del orden de ejecución. Los cuatro bytes producen `000fa5ff`, de longitud `8`.
Lecciones relacionadas
- Java · Lección 28 · Avanzado · Versión: 2
- Java · Lección 35 · Avanzado · Versión: 2
- Java · Lección 62 · Avanzado · Versión: 2