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