База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Директен ByteBuffer: запис, четене и запазване на непрочетените байтове

Запиши шест байта в 32-байтов директен буфер и виж как `flip()`, `compact()` и `clear()` променят диапазона, достъпен за четене или запис.

Версия: Java SE 21

Синтаксис

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

В Java SE 21 статичният метод java.nio.ByteBuffer.allocateDirect(n) създава директен буфер за n байта. Отрицателен капацитет предизвиква IllegalArgumentException. isDirect() показва дали буферът е директен. JVM се стреми да избегне междинно копиране при входно-изходни операции на ниво операционна система, но не го гарантира. Съдържанието може да е извън паметта на Java за динамично заделяне (heap). Нито една от разгледаните операции не освобождава паметта на буфера.

capacity() връща постоянния капацитет в байтове, position() показва индекса на следващия байт при относителен достъп, а limit() — първия недостъпен индекс. Първоначално позицията е 0, границата е равна на капацитета и байтовете са занулени. position(p) изисква 0 <= p <= limit; limit(l) изисква 0 <= l <= capacity и намалява позицията до l, ако е нужно. Невалиден аргумент предизвиква IllegalArgumentException. Всеки от двата метода премахва отметката, ако тя е след новата позиция или след новата граница, съответно.

order() връща реда на байтовете, първоначално ByteOrder.BIG_ENDIAN (първо старшият байт). order(ByteOrder.LITTLE_ENDIAN) поставя младшия байт първи при следващи многобайтови операции, без да пренарежда записаните байтове. Следвай реда, определен от формата на данните, а не от процесора.

putInt(value) и getInt() записват или четат четири байта; putShort(value) и getShort() използват два. Относителните операции започват от position() и я преместват с размера на стойността. Ако limit - position е твърде малко, четенето предизвиква BufferUnderflowException, а записът в буфер, който позволява запис — BufferOverflowException. Опитът за запис в буфер само за четене може да предизвика ReadOnlyBufferException. Ако в буфер само за четене няма и достатъчно място за относителен запис, Java SE 21 не определя кое от двете изключения при запис има предимство. Абсолютните варианти getInt(i), getShort(i), putInt(i, value) и putShort(i, value) не променят позицията. Целият им байтов диапазон трябва да е в [0, limit), иначе възниква IndexOutOfBoundsException.

flip() задава старата позиция като граница и връща позицията на 0 за четене. clear() задава позиция 0 и граница, равна на капацитета, за да позволи запис в целия буфер, без да изтрива данните. След частично четене compact() премества байтовете от [position, limit) в началото, задава позицията на броя запазени байтове и връща границата до капацитета, за да могат да се добавят данни. Извикай flip() преди следващото четене. И трите метода премахват отметката; compact() предизвиква ReadOnlyBufferException при буфер само за четене.

Примери

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

Резултат

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

Данните заемат шест от 32 байта. Абсолютното извикване `get(0)` показва младшия байт (`4`), без да мести позицията. След прочитането на `int` методът `compact()` запазва двата байта на `200`; след добавяне на `300` второто `flip()` позволява да се прочетат и двете стойности. `clear()` възстановява пълния диапазон за запис.

Свързани уроци

  • Java · Урок 50 · Напреднало · Версия: 2

Източници