CKTIS / Java
ByteBuffer direto: escrever, ler e preservar os bytes não lidos
Escreve seis bytes num buffer direto de 32 bytes e vê como `flip()`, `compact()` e `clear()` alteram o intervalo disponível para leitura ou escrita.
Versão: Java SE 21
Sintaxe
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
ByteBuffer b = ByteBuffer.allocateDirect(32);
b.isDirect();
b.capacity();
b.order();
b.order(ByteOrder.LITTLE_ENDIAN);
b.position();
b.position(newPosition);
b.limit();
b.limit(newLimit);
b.putInt(intValue);
b.putInt(byteIndex, intValue);
b.putShort(shortValue);
b.putShort(byteIndex, shortValue);
b.getInt();
b.getInt(byteIndex);
b.getShort();
b.getShort(byteIndex);
b.clear();
b.flip();
b.compact();Em Java SE 21, o método estático java.nio.ByteBuffer.allocateDirect(n) cria um buffer direto de n bytes. Uma capacidade negativa provoca IllegalArgumentException. isDirect() indica se o buffer é direto. A JVM tenta evitar cópias intermédias nas operações nativas de entrada e saída, mas não o garante. O conteúdo pode ficar fora do heap de Java. Nenhuma das operações aqui abordadas liberta a memória do buffer.
capacity() devolve a capacidade fixa em bytes, position() indica o índice do próximo byte para um acesso relativo e limit() indica o primeiro índice inacessível. Inicialmente, a posição é 0, o limite é igual à capacidade e os bytes estão a zero. position(p) exige 0 <= p <= limit; limit(l) exige 0 <= l <= capacity e baixa a posição para l se necessário. Um argumento inválido provoca IllegalArgumentException. Cada método descarta a marca se esta ultrapassar a nova posição ou o novo limite, respetivamente.
order() devolve a ordem dos bytes, inicialmente ByteOrder.BIG_ENDIAN (primeiro o byte mais significativo). order(ByteOrder.LITTLE_ENDIAN) passa a usar primeiro o byte menos significativo nos acessos seguintes a vários bytes, sem reordenar os bytes guardados. Segue a ordem definida pelo formato dos dados, não pela CPU.
putInt(value) e getInt() escrevem ou leem quatro bytes; putShort(value) e getShort() usam dois. As operações relativas começam em position() e avançam-na pelo tamanho do valor. Se limit - position for insuficiente, a leitura lança BufferUnderflowException e a escrita num buffer que permite escrita lança BufferOverflowException. Uma tentativa de escrita num buffer só de leitura pode lançar ReadOnlyBufferException. Se também não houver espaço suficiente para uma escrita relativa num buffer só de leitura, Java SE 21 não especifica qual das duas exceções de escrita tem precedência. As sobrecargas absolutas getInt(i), getShort(i), putInt(i, value) e putShort(i, value) não alteram a posição. Todo o seu intervalo de bytes tem de caber em [0, limit); caso contrário, lançam IndexOutOfBoundsException.
flip() fixa o limite na posição anterior e repõe a posição em 0 para ler. clear() repõe a posição em 0 e o limite na capacidade para voltar a preencher todo o buffer, sem apagar dados. Após uma leitura parcial, compact() move os bytes de [position, limit) para o início, fixa a posição no número de bytes preservados e repõe o limite na capacidade para acrescentar dados. Usa flip() antes de voltares a ler. Os três métodos descartam a marca; compact() lança ReadOnlyBufferException num buffer só de leitura.
Exemplos
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class Main {
public static void main(String[] args) {
ByteBuffer b = ByteBuffer.allocateDirect(32).order(ByteOrder.LITTLE_ENDIAN);
System.out.println("direct=" + b.isDirect() + ", capacity=" + b.capacity()
+ ", order=" + b.order());
b.putInt(0x01020304).putShort((short) 200);
state("after put", b);
b.flip();
state("after flip", b);
System.out.println("first byte=" + b.get(0));
System.out.println("int=" + b.getInt());
state("after getInt", b);
b.compact();
state("after compact", b);
b.putShort((short) 300);
b.flip();
state("after second flip", b);
short retained = b.getShort();
short appended = b.getShort();
System.out.println("shorts=" + retained + ", " + appended);
b.clear();
state("after clear", b);
}
private static void state(String label, ByteBuffer b) {
System.out.println(label + ": position=" + b.position() + ", limit=" + b.limit());
}
}Resultado
direct=true, capacity=32, order=LITTLE_ENDIAN after put: position=6, limit=32 after flip: position=0, limit=6 first byte=4 int=16909060 after getInt: position=4, limit=6 after compact: position=2, limit=32 after second flip: position=0, limit=4 shorts=200, 300 after clear: position=0, limit=32
Os dados ocupam seis dos 32 bytes. A chamada absoluta `get(0)` mostra o byte menos significativo (`4`) sem avançar a posição. Depois de ler o `int`, `compact()` preserva os dois bytes de `200`; após acrescentar `300`, o segundo `flip()` permite ler os dois valores. `clear()` repõe todo o intervalo de escrita.
Lições relacionadas
- Java · Lição 50 · Avançado · Versão: 2