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

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

Fontes