CKTIS / Java
ByteBuffer: gedeelde array, capaciteit en lezen zonder positiewijziging
Gebruik een bestaande byte-array zonder kopie, onderscheid capaciteit van limiet en lees een byte op een gekozen index zonder de bufferpositie te wijzigen.
Versie: 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();De statische methode wrap van java.nio.ByteBuffer maakt een buffer die een bestaande byte[] gebruikt, zonder de gegevens te kopiëren. Wijzigingen in de array zijn zichtbaar in de buffer, en schrijven via de buffer wijzigt dezelfde array. Bij ByteBuffer.wrap(array) is de beginpositie 0 en zijn de limiet en capaciteit beide gelijk aan array.length.
De overload ByteBuffer.wrap(array, offset, length) stelt de beginpositie in op offset en de limiet op offset + length. De capaciteit blijft array.length. Er moet gelden dat 0 <= offset <= array.length en 0 <= length <= array.length - offset; anders werpt de methode een IndexOutOfBoundsException. Index 0 verwijst nog steeds naar array[0], niet naar array[offset].
De van java.nio.Buffer geërfde methode capacity() geeft de vaste capaciteit van de buffer in bytes terug, niet het aantal bytes dat nog beschikbaar is voor relatief lezen. Daarvoor geeft remaining() de waarde limit() - position(). Er geldt altijd 0 <= position() <= limit() <= capacity().
get(index) leest één byte op een index die vanaf het begin van de buffer wordt geteld, zonder de positie te wijzigen. De index mag vóór de huidige positie liggen, maar moet voldoen aan 0 <= index < limit(); anders werpt de methode een IndexOutOfBoundsException. De relatieve methode get() leest daarentegen op de huidige positie en verhoogt deze met één. Is de positie gelijk aan de limiet, dan werpt de methode een BufferUnderflowException.
Voorbeelden
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]);
}
}Resultaat
capacity=4 limit=3 get(0)=11 position=1 get()=20 position=2 data[2]=33
Met positie `1` en limiet `3` leest `get(0)` de waarde `11` die in de array is geschreven, zonder de positie te wijzigen. De volgende `get()` geeft `20` terug en schuift de positie door naar `2`. Schrijven via de buffer verandert `data[2]` in `33`. `get(3)` zou een uitzondering werpen: `3` is gelijk aan de limiet, ook al is het kleiner dan de capaciteit van `4`.
Gerelateerde lessen
- Java · Les 60 · Gemiddeld · Versie: 2