WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Direkter ByteBuffer: schreiben, lesen und ungelesene Bytes behalten

Schreibe sechs Bytes in einen direkten 32-Byte-Puffer und beobachte, wie `flip()`, `compact()` und `clear()` den Lese- oder Schreibbereich ändern.

Version: Java SE 21

Syntax

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 erzeugt die statische Methode java.nio.ByteBuffer.allocateDirect(n) einen direkten Puffer für n Bytes. Eine negative Kapazität führt zu IllegalArgumentException. isDirect() prüft, ob der Puffer direkt ist. Die JVM versucht bei nativer Ein-/Ausgabe, Zwischenkopien zu vermeiden, garantiert dies aber nicht. Der Inhalt kann außerhalb des Java-Heaps liegen. Keine der hier behandelten Operationen gibt den Pufferspeicher frei.

capacity() liefert die feste Kapazität in Bytes, position() den nächsten Byteoffset für relative Zugriffe und limit() den ersten nicht zugänglichen Offset. Anfangs ist die Position 0, das Limit entspricht der Kapazität und die Bytes sind null. position(p) verlangt 0 <= p <= limit; limit(l) verlangt 0 <= l <= capacity und senkt die Position bei Bedarf auf l. Ungültige Argumente führen zu IllegalArgumentException. Der jeweilige Setter verwirft die Marke, wenn sie über der neuen Position bzw. dem neuen Limit liegt.

order() liefert die Byte-Reihenfolge, anfangs ByteOrder.BIG_ENDIAN (höchstwertiges Byte zuerst). order(ByteOrder.LITTLE_ENDIAN) verwendet bei späteren Mehrbytezugriffen das niedrigstwertige Byte zuerst, ohne gespeicherte Bytes umzusortieren. Richte dich nach dem Datenformat, nicht nach der CPU.

putInt(value) und getInt() schreiben oder lesen vier Bytes, putShort(value) und getShort() zwei. Relative Zugriffe beginnen bei position() und erhöhen sie um die jeweilige Byteanzahl. Ist limit - position zu klein, führt Lesen zu BufferUnderflowException und Schreiben in einen beschreibbaren Puffer zu BufferOverflowException. Ein Schreibversuch in einen schreibgeschützten Puffer kann ReadOnlyBufferException auslösen. Wenn in einem schreibgeschützten Puffer zugleich zu wenig Platz für einen relativen Schreibzugriff bleibt, legt Java SE 21 nicht fest, welche der beiden Ausnahmen beim Schreiben Vorrang hat. Die absoluten Überladungen getInt(i), getShort(i), putInt(i, value) und putShort(i, value) ändern die Position nicht. Ihr gesamter Bytebereich muss in [0, limit) liegen, sonst folgt IndexOutOfBoundsException.

flip() übernimmt die alte Position als Limit und setzt die Position zum Lesen auf 0. clear() setzt die Position auf 0 und das Limit auf die Kapazität, um den ganzen Puffer neu zu beschreiben, ohne Daten zu löschen. Nach teilweisem Lesen verschiebt compact() die Bytes aus [position, limit) an den Anfang, setzt die Position auf deren Anzahl und das Limit auf die Kapazität. So kannst du direkt weitere Daten anhängen. Rufe vor dem erneuten Lesen flip() auf. Alle drei Methoden verwerfen die Marke; compact() führt bei einem schreibgeschützten Puffer zu ReadOnlyBufferException.

Beispiele

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

Ergebnis

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

Die Nutzdaten belegen sechs von 32 Bytes. Das absolute `get(0)` zeigt das niedrigstwertige Byte (`4`), ohne die Position zu ändern. Nach dem Lesen des `int` bewahrt `compact()` die zwei Bytes für `200`. Nach dem Anhängen von `300` macht das zweite `flip()` beide Werte lesbar. `clear()` stellt den vollen Schreibbereich wieder her.

Zugehörige Lektionen

  • Java · Lektion 50 · Fortgeschritten · Version: 2

Quellen