Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

ByteBuffer: array condiviso, capacità e lettura senza cambiare posizione

Usa un array di byte esistente senza copiarlo, distingui la capacità dal limite e leggi un byte a un indice preciso senza cambiare la posizione del buffer.

Versione: Java SE 21

Sintassi

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

Il metodo statico wrap di java.nio.ByteBuffer crea un buffer che usa un byte[] esistente senza copiare i dati. Le modifiche all’array sono visibili nel buffer e le scritture tramite il buffer modificano lo stesso array. Con ByteBuffer.wrap(array) la posizione iniziale è 0, mentre il limite e la capacità sono pari a array.length.

L’overload ByteBuffer.wrap(array, offset, length) imposta la posizione iniziale a offset e il limite a offset + length, ma la capacità rimane array.length. Devono valere 0 <= offset <= array.length e 0 <= length <= array.length - offset; in caso contrario il metodo lancia IndexOutOfBoundsException. L’indice 0 corrisponde ancora a array[0], non a array[offset].

Il metodo capacity(), ereditato da java.nio.Buffer, restituisce la capacità fissa del buffer in byte, non il numero di byte ancora disponibili per la lettura relativa. Per questo c’è remaining(), che restituisce limit() - position(). Vale sempre 0 <= position() <= limit() <= capacity().

get(index) legge un byte a un indice contato dall’inizio del buffer e non cambia la posizione. L’indice può precedere la posizione corrente, ma deve rispettare 0 <= index < limit(); altrimenti il metodo lancia IndexOutOfBoundsException. Al contrario, get() legge alla posizione corrente e la incrementa di uno; se la posizione è uguale al limite, lancia BufferUnderflowException.

Esempi

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

Risultato

capacity=4
limit=3
get(0)=11
position=1
get()=20
position=2
data[2]=33

Con posizione `1` e limite `3`, `get(0)` legge il valore `11` scritto nell’array e lascia invariata la posizione. Il successivo `get()` restituisce `20` e porta la posizione a `2`. La scrittura tramite il buffer imposta `data[2]` a `33`. `get(3)` lancerebbe un’eccezione: `3` coincide con il limite, anche se è minore della capacità `4`.

Lezioni correlate

  • Java · Lezione 60 · Intermedio · Versione: 2

Fonti