KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Directe ByteBuffer: schrijven, lezen en ongelezen bytes behouden

Schrijf zes bytes in een directe buffer van 32 bytes en zie hoe `flip()`, `compact()` en `clear()` het lees- of schrijfbereik wijzigen.

Versie: 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 maakt de statische methode java.nio.ByteBuffer.allocateDirect(n) een directe buffer van n bytes. Een negatieve capaciteit leidt tot IllegalArgumentException. isDirect() geeft aan of de buffer direct is. De JVM probeert tussenkopieën bij native I/O te vermijden, maar garandeert dat niet. De inhoud kan buiten de Java-heap liggen. Geen van de hier behandelde bewerkingen geeft het buffergeheugen vrij.

capacity() geeft de vaste capaciteit in bytes, position() de index van de volgende byte bij relatieve toegang en limit() de eerste ontoegankelijke index. Aanvankelijk is de positie 0, is de limiet gelijk aan de capaciteit en staan alle bytes op nul. position(p) vereist 0 <= p <= limit; limit(l) vereist 0 <= l <= capacity en verlaagt de positie zo nodig tot l. Een ongeldig argument veroorzaakt IllegalArgumentException. Elke setter wist de markering als die boven de nieuwe positie respectievelijk limiet ligt.

order() geeft de bytevolgorde, aanvankelijk ByteOrder.BIG_ENDIAN (meest significante byte eerst). order(ByteOrder.LITTLE_ENDIAN) zet bij volgende bewerkingen op meerdere bytes de minst significante byte voorop, zonder opgeslagen bytes te herschikken. Gebruik de volgorde van het gegevensformaat, niet die van de processor.

putInt(value) en getInt() schrijven of lezen vier bytes; putShort(value) en getShort() gebruiken er twee. Relatieve bewerkingen beginnen bij position() en verhogen die met het aantal bytes van de waarde. Als limit - position te klein is, veroorzaakt lezen BufferUnderflowException en schrijven naar een beschrijfbare buffer BufferOverflowException. Een schrijfpoging naar een alleen-lezenbuffer kan ReadOnlyBufferException veroorzaken. Als een alleen-lezenbuffer ook te weinig ruimte heeft voor een relatieve schrijfbewerking, legt Java SE 21 niet vast welke van de twee schrijfexcepties voorrang heeft. De absolute overloads getInt(i), getShort(i), putInt(i, value) en putShort(i, value) wijzigen de positie niet. Hun volledige bytebereik moet binnen [0, limit) vallen, anders volgt IndexOutOfBoundsException.

flip() stelt de limiet in op de oude positie en zet de positie op 0 om te lezen. clear() zet de positie op 0 en de limiet op de capaciteit om de hele buffer opnieuw te vullen zonder gegevens te wissen. Na gedeeltelijk lezen verplaatst compact() de bytes uit [position, limit) naar het begin, zet de positie op het aantal behouden bytes en herstelt de limiet tot de capaciteit, zodat je gegevens kunt toevoegen. Roep vóór het opnieuw lezen flip() aan. Alle drie wissen de markering; compact() veroorzaakt ReadOnlyBufferException bij een alleen-lezenbuffer.

Voorbeelden

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

Resultaat

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

De gegevens beslaan zes van de 32 bytes. De absolute aanroep `get(0)` toont de minst significante byte (`4`) zonder de positie te verhogen. Na het lezen van de `int` bewaart `compact()` de twee bytes van `200`; na het toevoegen van `300` maakt de tweede `flip()` beide waarden leesbaar. `clear()` herstelt het volledige schrijfbereik.

Gerelateerde lessen

  • Java · Les 50 · Gevorderd · Versie: 2

Bronnen