WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

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

Quellen