CKTIS / Java
ByteBuffer: array partilhado, capacidade e leitura sem alterar a posição
Use um array de bytes existente sem o copiar, distinga a capacidade do limite e leia um byte num índice específico sem alterar a posição do buffer.
Versão: Java SE 21
Sintaxe
import java.nio.ByteBuffer;
ByteBuffer buffer = ByteBuffer.wrap(array);
ByteBuffer window = ByteBuffer.wrap(array, offset, length);
int capacity = buffer.capacity();
byte atIndex = buffer.get(index);
byte next = buffer.get();O método estático wrap de java.nio.ByteBuffer cria um buffer que usa um byte[] existente, sem copiar os dados. As escritas no array são visíveis no buffer, e as escritas através do buffer alteram esse mesmo array. Com ByteBuffer.wrap(array), a posição inicial é 0 e tanto o limite como a capacidade são iguais a array.length.
A sobrecarga ByteBuffer.wrap(array, offset, length) define a posição inicial como offset e o limite como offset + length, mas a capacidade continua a ser array.length. É necessário que 0 <= offset <= array.length e 0 <= length <= array.length - offset; caso contrário, o método lança IndexOutOfBoundsException. O índice 0 continua a corresponder a array[0], não a array[offset].
O método capacity(), herdado de java.nio.Buffer, devolve a capacidade fixa do buffer em bytes, não o número de bytes ainda disponíveis para leitura relativa. Para isso, remaining() devolve limit() - position(). A relação 0 <= position() <= limit() <= capacity() é sempre válida.
get(index) lê um byte num índice contado desde o início do buffer e não altera a posição. O índice pode ser inferior à posição atual, mas tem de respeitar 0 <= index < limit(); caso contrário, o método lança IndexOutOfBoundsException. Já get() lê na posição atual e avança uma posição; se a posição for igual ao limite, lança BufferUnderflowException.
Exemplos
import java.nio.ByteBuffer;
public class Main {
public static void main(String[] args) {
byte[] data = {10, 20, 30, 40};
ByteBuffer buffer = ByteBuffer.wrap(data, 1, 2);
System.out.println("capacity=" + buffer.capacity());
System.out.println("limit=" + buffer.limit());
data[0] = 11;
System.out.println("get(0)=" + buffer.get(0));
System.out.println("position=" + buffer.position());
System.out.println("get()=" + buffer.get());
System.out.println("position=" + buffer.position());
buffer.put(2, (byte) 33);
System.out.println("data[2]=" + data[2]);
}
}Resultado
capacity=4 limit=3 get(0)=11 position=1 get()=20 position=2 data[2]=33
Com a posição em `1` e o limite em `3`, `get(0)` lê o valor `11` escrito no array e mantém a posição. O `get()` seguinte devolve `20` e avança a posição para `2`. A escrita através do buffer altera `data[2]` para `33`. `get(3)` lançaria uma exceção: `3` é igual ao limite, apesar de ser inferior à capacidade de `4`.
Lições relacionadas
- Java · Lição 60 · Intermédio · Versão: 2