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