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

CKTIS / Java

StringBuilder: capacidade inicial, comprimento e crescimento do buffer

Distingue a capacidade do buffer do comprimento do texto, encadeia chamadas a append e verifica o crescimento sem depender de uma capacidade final específica.

Versão: Java SE 21

Sintaxe

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

Em Java SE 21, java.lang.StringBuilder guarda texto mutável. StringBuilder() cria um objeto vazio com capacidade 16; StringBuilder(int) cria um objeto vazio com exatamente a capacidade indicada. Em ambos os casos, o comprimento inicial é 0. Uma capacidade negativa lança NegativeArraySizeException.

length() conta as unidades de código UTF-16 (char) já armazenadas, não os pontos de código Unicode. capacity() indica quantas unidades de código cabem no buffer atual no total, incluindo as já armazenadas. Não indica o número de lugares livres nem um tamanho em bytes. Se o texto acrescentado ultrapassar essa capacidade, o buffer cresce automaticamente.

append(String) acrescenta texto no fim; um argumento do tipo String com o valor null acrescenta "null". append(int) acrescenta a representação decimal do inteiro, não o caráter com esse código. Ambas as sobrecargas alteram e devolvem o mesmo objeto, o que permite encadear chamadas.

toString() devolve um String imutável com o texto atual. Alterações posteriores ao builder não afetam esse resultado. Se conseguires estimar o comprimento final, escolher uma capacidade inicial adequada pode reduzir as realocações; essa capacidade não é um limite de comprimento.

Exemplos

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

Resultado

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

Ambos os objetos começam com comprimento 0. O segundo tem uma capacidade inicial de exatamente 4. As chamadas acrescentam `ID=` e `123`, e `toString()` devolve `ID=123`, com comprimento 6. O buffer teve de crescer; a verificação exige apenas `capacity() >= length()`, sem assumir uma capacidade específica após o crescimento.

Lições relacionadas

  • Java · Lição 49 · Avançado · Versão: 2

Fontes