CKTIS / Java
ByteBuffer : tableau partagé, capacité et lecture sans déplacer la position
Utilisez un tableau d’octets existant sans le copier, distinguez la capacité de la limite et lisez un octet à un indice donné sans déplacer la position.
Version : Java SE 21
Syntaxe
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();La méthode statique wrap de java.nio.ByteBuffer crée un tampon adossé à un tableau byte[] existant, sans copier les données. Une écriture dans le tableau est visible dans le tampon, et une écriture via le tampon modifie ce même tableau. Avec ByteBuffer.wrap(array), la position initiale vaut 0 ; la limite et la capacité valent array.length.
La surcharge ByteBuffer.wrap(array, offset, length) fixe la position initiale à offset et la limite à offset + length, mais la capacité reste égale à array.length. Il faut respecter 0 <= offset <= array.length et 0 <= length <= array.length - offset ; sinon, la méthode lève IndexOutOfBoundsException. L’indice 0 désigne toujours array[0], et non array[offset].
Héritée de java.nio.Buffer, la méthode capacity() renvoie la capacité fixe du tampon en octets, pas le nombre d’octets encore disponibles en lecture relative. C’est remaining() qui renvoie limit() - position(). La relation 0 <= position() <= limit() <= capacity() est toujours respectée.
get(index) lit un byte à un indice compté depuis le début du tampon sans modifier la position. L’indice peut précéder la position actuelle, mais doit respecter 0 <= index < limit() ; sinon, la méthode lève IndexOutOfBoundsException. À l’inverse, get() lit à la position actuelle et l’avance d’un cran ; si cette position est égale à la limite, la méthode lève BufferUnderflowException.
Exemples
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]);
}
}Résultat
capacity=4 limit=3 get(0)=11 position=1 get()=20 position=2 data[2]=33
Avec une position de `1` et une limite de `3`, `get(0)` lit la valeur `11` écrite dans le tableau et laisse la position inchangée. Le `get()` suivant renvoie `20` et avance la position à `2`. L’écriture via le tampon donne la valeur `33` à `data[2]`. `get(3)` lèverait une exception : `3` est égal à la limite, même s’il est inférieur à la capacité de `4`.
Leçons associées
- Java · Leçon 60 · Intermédiaire · Version : 2