Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Bezpośredni ByteBuffer: zapis, odczyt i zachowanie nieodczytanych bajtów

Zapisz sześć bajtów w 32-bajtowym buforze bezpośrednim i zobacz, jak `flip()`, `compact()` oraz `clear()` zmieniają zakres odczytu lub zapisu.

Wersja: Java SE 21

Składnia

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

W Java SE 21 statyczna metoda java.nio.ByteBuffer.allocateDirect(n) tworzy bezpośredni bufor o pojemności n bajtów; ujemna wartość powoduje IllegalArgumentException. isDirect() sprawdza, czy bufor jest bezpośredni. JVM próbuje uniknąć dodatkowego kopiowania przy natywnym wejściu/wyjściu, ale go nie wyklucza. Zawartość może znajdować się poza stertą Javy. Żadna z omawianych operacji nie zwalnia pamięci bufora.

capacity() zwraca stałą pojemność w bajtach, position() wskazuje następny bajt dostępu względnego, a limit() wskazuje pierwszy niedostępny indeks. Na początku pozycja wynosi 0, limit jest równy pojemności, a bajty są wyzerowane. position(p) wymaga 0 <= p <= limit, a limit(l) wymaga 0 <= l <= capacity i obniża pozycję do l, jeśli była większa. Nieprawidłowy argument powoduje IllegalArgumentException; oba settery odrzucają znacznik (mark), jeśli przekracza odpowiednio nową pozycję lub limit.

order() zwraca kolejność bajtów, początkowo ByteOrder.BIG_ENDIAN (najstarszy bajt pierwszy). order(ByteOrder.LITTLE_ENDIAN) ustawia najmłodszy bajt jako pierwszy dla kolejnych operacji wielobajtowych, bez zmiany już zapisanych bajtów. Dobierz kolejność do formatu danych, a nie do procesora.

putInt(value) i getInt() zapisują lub odczytują cztery bajty; putShort(value) i getShort() — dwa. Operacje względne zaczynają od position() i przesuwają ją o rozmiar wartości. Gdy limit - position jest za małe, odczyt zgłasza BufferUnderflowException, a zapis do bufora dopuszczającego zapis zgłasza BufferOverflowException. Próba zapisu do bufora tylko do odczytu może spowodować ReadOnlyBufferException. Jeśli taki bufor ma też za mało miejsca na zapis względny, Java SE 21 nie określa, który z tych dwóch wyjątków zapisu ma pierwszeństwo. Warianty bezwzględne getInt(i), getShort(i), putInt(i, value) i putShort(i, value) nie zmieniają pozycji. Ich zakres bajtowy musi mieścić się w [0, limit), inaczej wystąpi IndexOutOfBoundsException.

flip() ustawia limit na starą pozycję i cofa pozycję do 0, przygotowując bufor do odczytu. clear() ustawia pozycję na 0, a limit na pojemność, przygotowując pełny zakres do zapisu bez kasowania danych. Po częściowym odczycie compact() przenosi bajty z [position, limit) na początek, ustawia pozycję na liczbę zachowanych bajtów, a limit na pojemność, by można było dopisać dane. Przed ponownym odczytem użyj flip(). Wszystkie trzy metody odrzucają znacznik; compact() zgłasza ReadOnlyBufferException dla bufora tylko do odczytu.

Przykłady

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

Wynik

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

Ładunek zajmuje sześć z 32 bajtów. Bezwzględne `get(0)` pokazuje najmłodszy bajt (`4`), nie przesuwając pozycji. Po odczycie `int` metoda `compact()` zachowuje dwa bajty wartości `200`; po dopisaniu `300` drugie `flip()` udostępnia obie wartości. `clear()` przywraca pełny zakres zapisu.

Powiązane lekcje

  • Java · Lekcja 50 · Zaawansowany · Wersja: 2

Źródła