Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

ByteBuffer direct : écrire, lire et conserver les octets non lus

Écris six octets dans un tampon direct de 32 octets et observe comment `flip()`, `compact()` et `clear()` modifient la plage de lecture ou d’écriture.

Version : Java SE 21

Syntaxe

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

Dans Java SE 21, la méthode statique java.nio.ByteBuffer.allocateDirect(n) crée un tampon direct de n octets. Une capacité négative déclenche IllegalArgumentException. isDirect() indique si le tampon est direct. La JVM tente d’éviter les copies intermédiaires lors des entrées-sorties natives, sans le garantir. Le contenu peut se trouver hors du tas Java. Aucune des opérations présentées ici ne libère la mémoire du tampon.

capacity() renvoie la capacité fixe en octets, position() donne l’indice du prochain octet pour un accès relatif et limit() donne le premier indice inaccessible. Au départ, la position vaut 0, la limite égale la capacité et les octets valent zéro. position(p) exige 0 <= p <= limit ; limit(l) exige 0 <= l <= capacity et ramène la position à l si nécessaire. Un argument invalide déclenche IllegalArgumentException. Chaque méthode de réglage efface la marque si elle dépasse, respectivement, la nouvelle position ou la nouvelle limite.

order() indique l’ordre des octets, initialement ByteOrder.BIG_ENDIAN (octet de poids fort en premier). order(ByteOrder.LITTLE_ENDIAN) place l’octet de poids faible en premier lors des accès suivants à plusieurs octets, sans réorganiser les octets stockés. Suis le format des données plutôt que l’ordre du processeur.

putInt(value) et getInt() écrivent ou lisent quatre octets ; putShort(value) et getShort() en utilisent deux. Les opérations relatives démarrent à position() et l’avancent de la taille de la valeur. Si limit - position est trop petit, la lecture déclenche BufferUnderflowException et l’écriture dans un tampon accessible en écriture déclenche BufferOverflowException. Une tentative d’écriture dans un tampon en lecture seule peut déclencher ReadOnlyBufferException. S’il ne reste pas assez de place pour une écriture relative dans un tampon en lecture seule, Java SE 21 ne précise pas laquelle des deux exceptions d’écriture est prioritaire. Les surcharges absolues getInt(i), getShort(i), putInt(i, value) et putShort(i, value) ne déplacent pas la position. Toute leur plage doit tenir dans [0, limit), sinon elles déclenchent IndexOutOfBoundsException.

flip() reprend l’ancienne position comme limite et met la position à 0 pour lire. clear() remet la position à 0 et la limite à la capacité pour réécrire dans tout le tampon, sans effacer les données. Après une lecture partielle, compact() déplace les octets de [position, limit) au début, fixe la position à leur nombre et rétablit la limite à la capacité pour ajouter des données. Appelle flip() avant de relire. Les trois méthodes effacent la marque ; compact() déclenche ReadOnlyBufferException sur un tampon en lecture seule.

Exemples

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

Résultat

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

Les données occupent six des 32 octets. L’accès absolu `get(0)` affiche l’octet de poids faible (`4`) sans avancer la position. Après la lecture du `int`, `compact()` conserve les deux octets de `200` ; après l’ajout de `300`, le second `flip()` rend les deux valeurs lisibles. `clear()` rétablit toute la plage d’écriture.

Leçons associées

  • Java · Leçon 50 · Avancé · Version : 2

Sources