CKTIS / Java
ByteBuffer: gemeinsames Array, Kapazität und Lesen ohne Positionsänderung
Verwende ein vorhandenes Byte-Array ohne Kopie, unterscheide Kapazität und Limit und lies ein Byte an einem bestimmten Index, ohne die Pufferposition zu ändern.
Version: Java SE 21
Syntax
import java.nio.ByteBuffer;
ByteBuffer buffer = ByteBuffer.wrap(array);
ByteBuffer window = ByteBuffer.wrap(array, offset, length);
int capacity = buffer.capacity();
byte atIndex = buffer.get(index);
byte next = buffer.get();Die statische Methode wrap von java.nio.ByteBuffer erstellt einen Puffer auf Basis eines vorhandenen byte[], ohne die Daten zu kopieren. Änderungen am Array sind im Puffer sichtbar, und Schreibzugriffe über den Puffer ändern dasselbe Array. Bei ByteBuffer.wrap(array) ist die Anfangsposition 0; Limit und Kapazität entsprechen array.length.
Die Überladung ByteBuffer.wrap(array, offset, length) setzt die Anfangsposition auf offset und das Limit auf offset + length. Die Kapazität bleibt array.length. Es muss 0 <= offset <= array.length und 0 <= length <= array.length - offset gelten; sonst wird eine IndexOutOfBoundsException ausgelöst. Index 0 bezeichnet weiterhin array[0], nicht array[offset].
Die von java.nio.Buffer geerbte Methode capacity() gibt die feste Kapazität in Bytes zurück, nicht die Zahl der für relative Lesezugriffe verbleibenden Bytes. Diese liefert remaining() als limit() - position(). Es gilt 0 <= position() <= limit() <= capacity().
get(index) liest ein byte an einem vom Pufferanfang gezählten Index, ohne die Position zu ändern. Der Index darf kleiner als die aktuelle Position sein, muss aber 0 <= index < limit() erfüllen; sonst folgt eine IndexOutOfBoundsException. Das relative get() liest dagegen an der aktuellen Position und erhöht sie um eins. Entspricht die Position dem Limit, wird eine BufferUnderflowException ausgelöst.
Beispiele
import java.nio.ByteBuffer;
public class Main {
public static void main(String[] args) {
byte[] data = {10, 20, 30, 40};
ByteBuffer buffer = ByteBuffer.wrap(data, 1, 2);
System.out.println("capacity=" + buffer.capacity());
System.out.println("limit=" + buffer.limit());
data[0] = 11;
System.out.println("get(0)=" + buffer.get(0));
System.out.println("position=" + buffer.position());
System.out.println("get()=" + buffer.get());
System.out.println("position=" + buffer.position());
buffer.put(2, (byte) 33);
System.out.println("data[2]=" + data[2]);
}
}Ergebnis
capacity=4 limit=3 get(0)=11 position=1 get()=20 position=2 data[2]=33
Bei Position `1` und Limit `3` liest `get(0)` die ins Array geschriebene `11`, ohne die Position zu ändern. Das anschließende `get()` liefert `20` und setzt die Position auf `2`. Der Schreibzugriff über den Puffer setzt `data[2]` auf `33`. `get(3)` würde eine Ausnahme auslösen: `3` entspricht dem Limit, obwohl der Index unter der Kapazität `4` liegt.
Zugehörige Lektionen
- Java · Lektion 60 · Mittlere Stufe · Version: 2