Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

ByteBuffer: array compartido, capacidad y lectura sin mover la posición

Usa un array de bytes existente sin copiarlo, distingue la capacidad del límite y lee un byte en un índice concreto sin mover la posición del búfer.

Versión: Java SE 21

Sintaxis

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

El método estático wrap de java.nio.ByteBuffer crea un búfer respaldado por un byte[] existente, sin copiar los datos. Los cambios en el array se ven en el búfer, y las escrituras a través del búfer modifican ese mismo array. Con ByteBuffer.wrap(array), la posición inicial es 0 y tanto el límite como la capacidad valen array.length.

La sobrecarga ByteBuffer.wrap(array, offset, length) fija la posición inicial en offset y el límite en offset + length, pero mantiene la capacidad en array.length. Exige 0 <= offset <= array.length y 0 <= length <= array.length - offset; si no se cumplen, lanza IndexOutOfBoundsException. El índice 0 sigue correspondiendo a array[0], no a array[offset].

El método capacity(), heredado de java.nio.Buffer, devuelve la capacidad fija del búfer en bytes, no la cantidad de bytes que quedan para una lectura relativa. Para eso, remaining() devuelve limit() - position(). Siempre se cumple 0 <= position() <= limit() <= capacity().

get(index) lee un byte en un índice que se cuenta desde el inicio del búfer, sin cambiar la posición. El índice puede ser inferior a la posición actual, pero debe cumplir 0 <= index < limit(); de lo contrario, el método lanza IndexOutOfBoundsException. En cambio, get() lee en la posición actual y la incrementa en uno; si la posición es igual al límite, lanza BufferUnderflowException.

Ejemplos

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

Resultado

capacity=4
limit=3
get(0)=11
position=1
get()=20
position=2
data[2]=33

Con la posición en `1` y el límite en `3`, `get(0)` lee el `11` escrito en el array y deja la posición intacta. El siguiente `get()` devuelve `20` y mueve la posición a `2`. La escritura a través del búfer cambia `data[2]` a `33`. `get(3)` lanzaría una excepción: `3` es igual al límite, aunque sea menor que la capacidad de `4`.

Lecciones relacionadas

  • Java · Lección 60 · Intermedio · Versión: 2

Fuentes