CKTIS / Java
ByteBuffer diretto: scrivere, leggere e conservare i byte non letti
Scrivi sei byte in un buffer diretto da 32 byte e osserva come `flip()`, `compact()` e `clear()` modificano l’intervallo di lettura o scrittura.
Versione: Java SE 21
Sintassi
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();In Java SE 21, il metodo statico java.nio.ByteBuffer.allocateDirect(n) crea un buffer diretto di n byte. Una capacità negativa causa IllegalArgumentException. isDirect() indica se il buffer è diretto. La JVM cerca di evitare copie intermedie nell’I/O nativo, ma non lo garantisce. Il contenuto può risiedere al di fuori dello heap Java. Nessuna delle operazioni trattate qui libera la memoria del buffer.
capacity() restituisce la capacità fissa in byte, position() indica l’indice del prossimo byte per un accesso relativo e limit() il primo indice inaccessibile. All’inizio la posizione è 0, il limite coincide con la capacità e i byte valgono zero. position(p) richiede 0 <= p <= limit; limit(l) richiede 0 <= l <= capacity e abbassa la posizione a l se necessario. Un argomento non valido causa IllegalArgumentException. Ciascun metodo scarta il marcatore se supera, rispettivamente, la nuova posizione o il nuovo limite.
order() restituisce l’ordine dei byte, inizialmente ByteOrder.BIG_ENDIAN (prima il byte più significativo). order(ByteOrder.LITTLE_ENDIAN) usa prima il byte meno significativo negli accessi successivi a più byte, senza riordinare quelli già memorizzati. Segui il formato dei dati, non l’ordine della CPU.
putInt(value) e getInt() scrivono o leggono quattro byte; putShort(value) e getShort() ne usano due. Le operazioni relative partono da position() e la fanno avanzare della dimensione del valore. Se limit - position è insufficiente, la lettura solleva BufferUnderflowException e la scrittura in un buffer scrivibile solleva BufferOverflowException. Un tentativo di scrittura in un buffer di sola lettura può sollevare ReadOnlyBufferException. Se in un buffer di sola lettura non c’è abbastanza spazio per una scrittura relativa, Java SE 21 non specifica quale delle due eccezioni di scrittura abbia la precedenza. Gli overload assoluti getInt(i), getShort(i), putInt(i, value) e putShort(i, value) non spostano la posizione. L’intero intervallo di byte deve rientrare in [0, limit), altrimenti sollevano IndexOutOfBoundsException.
flip() imposta il limite alla vecchia posizione e porta la posizione a 0 per leggere. clear() porta la posizione a 0 e il limite alla capacità per riscrivere l’intero buffer, senza cancellare i dati. Dopo una lettura parziale, compact() sposta all’inizio i byte di [position, limit), imposta la posizione al numero di byte conservati e riporta il limite alla capacità per poter aggiungere dati. Chiama flip() prima di leggere di nuovo. Tutti e tre i metodi scartano il marcatore; compact() solleva ReadOnlyBufferException su un buffer di sola lettura.
Esempi
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());
}
}Risultato
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
I dati occupano sei dei 32 byte. La chiamata assoluta `get(0)` mostra il byte meno significativo (`4`) senza far avanzare la posizione. Dopo la lettura dell’`int`, `compact()` conserva i due byte di `200`; aggiunto `300`, il secondo `flip()` rende leggibili entrambi i valori. `clear()` ripristina l’intero intervallo di scrittura.
Lezioni correlate
- Java · Lezione 50 · Avanzato · Versione: 2