CKTIS / Java
ByteBuffer directo: escribir, leer y conservar los bytes no leídos
Escribe seis bytes en un búfer directo de 32 bytes y observa cómo `flip()`, `compact()` y `clear()` cambian el intervalo de lectura o escritura.
Versión: Java SE 21
Sintaxis
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
ByteBuffer b = ByteBuffer.allocateDirect(32);
b.isDirect();
b.capacity();
b.order();
b.order(ByteOrder.LITTLE_ENDIAN);
b.position();
b.position(newPosition);
b.limit();
b.limit(newLimit);
b.putInt(intValue);
b.putInt(byteIndex, intValue);
b.putShort(shortValue);
b.putShort(byteIndex, shortValue);
b.getInt();
b.getInt(byteIndex);
b.getShort();
b.getShort(byteIndex);
b.clear();
b.flip();
b.compact();En Java SE 21, el método estático java.nio.ByteBuffer.allocateDirect(n) crea un búfer directo de n bytes. Una capacidad negativa provoca IllegalArgumentException. isDirect() indica si el búfer es directo. La JVM intenta evitar copias intermedias en la E/S nativa, pero no lo garantiza. El contenido puede estar fuera del montón de Java. Ninguna de las operaciones de esta entrada libera la memoria del búfer.
capacity() devuelve la capacidad fija en bytes, position() indica el índice del siguiente byte para un acceso relativo y limit() es el primer índice inaccesible. Al principio la posición es 0, el límite coincide con la capacidad y los bytes están a cero. position(p) exige 0 <= p <= limit; limit(l) exige 0 <= l <= capacity y reduce la posición a l si es necesario. Un argumento no válido provoca IllegalArgumentException. Cada método descarta la marca si supera la nueva posición o el nuevo límite, respectivamente.
order() devuelve el orden de bytes, inicialmente ByteOrder.BIG_ENDIAN (primero el byte más significativo). order(ByteOrder.LITTLE_ENDIAN) pone primero el byte menos significativo en los accesos posteriores de varios bytes, sin reordenar los bytes almacenados. Usa el orden del formato de datos, no el de la CPU.
putInt(value) y getInt() escriben o leen cuatro bytes; putShort(value) y getShort() usan dos. Las operaciones relativas parten de position() y la avanzan tantos bytes como ocupa el valor. Si limit - position es insuficiente, la lectura lanza BufferUnderflowException y la escritura en un búfer que admite escritura lanza BufferOverflowException. Un intento de escribir en un búfer de solo lectura puede lanzar ReadOnlyBufferException. Si en un búfer de solo lectura tampoco queda espacio suficiente para una escritura relativa, Java SE 21 no especifica cuál de las dos excepciones de escritura tiene prioridad. Las sobrecargas absolutas getInt(i), getShort(i), putInt(i, value) y putShort(i, value) no cambian la posición. Todo su intervalo de bytes debe caber en [0, limit); de lo contrario, lanzan IndexOutOfBoundsException.
flip() fija el límite en la posición anterior y pone la posición a 0 para leer. clear() pone la posición a 0 y el límite en la capacidad para volver a llenar todo el búfer, sin borrar los datos. Tras una lectura parcial, compact() mueve los bytes de [position, limit) al principio, fija la posición en el número de bytes conservados y el límite en la capacidad para poder añadir datos. Usa flip() antes de volver a leer. Los tres métodos descartan la marca; compact() lanza ReadOnlyBufferException en un búfer de solo lectura.
Ejemplos
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class Main {
public static void main(String[] args) {
ByteBuffer b = ByteBuffer.allocateDirect(32).order(ByteOrder.LITTLE_ENDIAN);
System.out.println("direct=" + b.isDirect() + ", capacity=" + b.capacity()
+ ", order=" + b.order());
b.putInt(0x01020304).putShort((short) 200);
state("after put", b);
b.flip();
state("after flip", b);
System.out.println("first byte=" + b.get(0));
System.out.println("int=" + b.getInt());
state("after getInt", b);
b.compact();
state("after compact", b);
b.putShort((short) 300);
b.flip();
state("after second flip", b);
short retained = b.getShort();
short appended = b.getShort();
System.out.println("shorts=" + retained + ", " + appended);
b.clear();
state("after clear", b);
}
private static void state(String label, ByteBuffer b) {
System.out.println(label + ": position=" + b.position() + ", limit=" + b.limit());
}
}Resultado
direct=true, capacity=32, order=LITTLE_ENDIAN after put: position=6, limit=32 after flip: position=0, limit=6 first byte=4 int=16909060 after getInt: position=4, limit=6 after compact: position=2, limit=32 after second flip: position=0, limit=4 shorts=200, 300 after clear: position=0, limit=32
Los datos ocupan seis de los 32 bytes. La llamada absoluta `get(0)` muestra el byte menos significativo (`4`) sin avanzar la posición. Tras leer el `int`, `compact()` conserva los dos bytes de `200`; después de añadir `300`, el segundo `flip()` permite leer ambos valores. `clear()` restablece todo el intervalo de escritura.
Lecciones relacionadas
- Java · Lección 50 · Avanzado · Versión: 2