HOWTO · Java

Clase Byte Buffer en Java

Aprenda cómo la posición, el límite y la capacidad de ByteBuffer en Java controlan la lectura y escritura de bytes, cómo crear y usar un búfer, y cómo dos ejemplos de Java leen bytes y caracteres con getChar().

En esta página

Un ByteBuffer almacena bytes y realiza un seguimiento de la siguiente posición para leer o escribir. Su posición, límite y capacidad determinan a qué bytes puede acceder una operación. Esta guía explica esos cambios de estado, los principales métodos de creación y acceso, y dos ejemplos de Java autónomos: uno para valores de bytes y otro para caracteres.

Clase ByteBuffer en Java

java.nio.ByteBuffer es un búfer NIO orientado a bytes que se usa para mover datos binarios entre el código Java y los canales de E/S. No almacena una serie de enteros como sus datos fundamentales; métodos como putInt() codifican un valor primitivo en bytes usando el orden de bytes del búfer.

Un búfer tiene tres valores de estado clave:

  • Capacidad es el tamaño fijo del búfer.
  • Posición es el índice del siguiente byte que usará una lectura o escritura relativa.
  • Límite es el primer índice que no se puede leer ni escribir. Es como máximo la capacidad.

Un búfer nuevo de allocate() tiene posición 0, límite igual a la capacidad y ningún dato escrito. put() relativo avanza la posición. Llamar a flip() establece el límite en la posición actual y restablece la posición a 0, preparando los bytes escritos para su lectura. get() relativo avanza la posición a medida que lee. clear() prepara todo el búfer para otra escritura restableciendo el límite a la capacidad y la posición a 0; no borra los bytes. rewind() restablece la posición a 0 manteniendo el límite actual, para que la misma región legible se pueda leer de nuevo.

La jerarquía de clases es Object → Buffer → ByteBuffer. Un búfer puede ser directo o no directo. allocateDirect() solicita almacenamiento fuera del montón ordinario de Java y puede ser útil para algunos patrones de E/S, pero no es automáticamente más rápido. Prefiera allocate() a menos que el almacenamiento directo se ajuste a las necesidades de E/S medidas de la aplicación.

Categorías operativas de la clase ByteBuffer en Java

Las operaciones de ByteBuffer se dividen en algunos grupos prácticos:

  • Creación: allocate(capacity) crea un búfer de montón, allocateDirect(capacity) solicita un búfer directo y wrap(byteArray) expone una matriz de bytes existente a través de un búfer.
  • Acceso relativo: get() y put(byte) usan la posición actual y la avanzan. Sus sobrecargas en bloque transfieren varios bytes y avanzan según el número transferido.
  • Acceso absoluto: get(index) y put(index, value) se dirigen a un índice específico sin cambiar la posición. El índice aún debe estar dentro del límite actual.
  • Valores primitivos y vistas: getInt(), putInt(value), getChar() y putChar(value) convierten entre valores primitivos y bytes. El ajuste order() determina el orden de bytes para estos valores de varios bytes. Una vista como asIntBuffer() interpreta los bytes como enteros sin cambiar la posición del búfer original.
  • Estado y búferes derivados: position(), limit(), remaining(), slice(), duplicate(), compact() y rewind() permiten que el código inspeccione o gestione la región legible y escribible.

La familia de métodos wrap() crea un búfer respaldado por una matriz existente: ByteBuffer.wrap(byte[]) envuelve bytes, no enteros. Para envolver un int[], use IntBuffer.wrap(intArray); crea un búfer de enteros y es una API diferente. Una matriz de bytes también se puede ver a través de un ByteBuffer como una secuencia de bytes, y luego interpretarse como valores primitivos según su orden de bytes.

Métodos de la clase Byte Buffer en Java

Los siguientes métodos cubren tareas comunes de creación, estado y acceso a datos:

Method Purpose
allocate(int capacity) Crea un ByteBuffer de montón con la capacidad solicitada.
allocateDirect(int capacity) Crea un ByteBuffer directo; la asignación puede tener costos diferentes del almacenamiento en el montón.
wrap(byte[] array) Crea un búfer respaldado por la matriz de bytes proporcionada.
capacity() Devuelve la capacidad fija.
position() / position(int) Lee o establece el siguiente índice de acceso relativo.
limit() / limit(int) Lee o establece el final de la región accesible.
remaining() Devuelve limit() - position().
get() / put(byte) Lee o escribe un byte en la posición actual y la avanza.
get(int) / put(int, byte) Lee o escribe en un índice sin cambiar la posición.
getInt() / putInt(int) and getChar() / putChar(char) Lee o escribe valores primitivos usando el orden de bytes actual.
order() / order(ByteOrder) Lee o establece el orden de bytes usado para valores primitivos de varios bytes.
hasArray() / array() Comprueba y devuelve una matriz de bytes de respaldo accesible. Es posible que los búferes directos y de solo lectura no expongan ninguna.
isDirect() Informa si el búfer es directo.
flip() / clear() / rewind() Cambia la posición y el límite para leer, escribir o volver a leer.
slice() / duplicate() / compact() Crea una vista, copia el estado del búfer en una vista relacionada o mueve los bytes restantes al principio para seguir escribiendo.
asIntBuffer() Crea una vista de enteros sobre los bytes restantes del búfer.

Para obtener detalles completos de la API, consulte la documentación de Java ByteBuffer.

Implementación de Byte Buffer en Java

Este ejemplo autónomo escribe dos valores de bytes, cambia el búfer a modo de lectura con flip() y luego lee los valores.

Este programa completo asigna un búfer de cuatro bytes, escribe dos valores, lo voltea para leerlo e imprime los valores y el estado actual.

import java.nio.ByteBuffer;

public class ByteBufferBytes {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.put((byte) 20);
        buffer.put((byte) 40);
        buffer.flip();

        byte first = buffer.get();
        byte second = buffer.get();
        System.out.println("bytes=" + first + "," + second);
        System.out.println("position=" + buffer.position()
                + ", limit=" + buffer.limit()
                + ", capacity=" + buffer.capacity());
    }
}

Salida esperada:

bytes=20,40
position=2, limit=2, capacity=4

Después de las dos lecturas, la posición es 2; el límite permanece en 2 y la capacidad permanece en 4. Una escritura absoluta como buffer.put(0, (byte) 7) cambia el byte en el índice 0 sin avanzar la posición. Una escritura relativa usa la posición actual y la avanza. Establecer la posición o el límite está restringido por el estado actual del búfer, así que establezca el límite antes de mover la posición más allá de él. remaining() informa cuántos bytes están disponibles entre la posición y el límite.

Implemente el método getChar de la clase Byte Buffer en Java

getChar() lee dos bytes en la posición actual y avanza la posición en dos. Establezca el orden de bytes explícitamente cuando el formato de datos de un búfer requiera un orden particular. El ejemplo escribe cuatro valores char de Java con putChar(), voltea el búfer y lee solo mientras queden al menos Character.BYTES. Esto usa el conteo de bytes conocido para detenerse de forma segura; no depende de un carácter cero como terminador.

import java.nio.ByteBuffer;
import java.nio.ByteOrder;

public class ByteBufferChars {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(4 * Character.BYTES)
                .order(ByteOrder.BIG_ENDIAN);
        buffer.putChar('J');
        buffer.putChar('A');
        buffer.putChar('V');
        buffer.putChar('A');
        buffer.flip();

        StringBuilder text = new StringBuilder();
        while (buffer.remaining() >= Character.BYTES) {
            text.append(buffer.getChar());
        }
        System.out.println(text);

        buffer.rewind();
        char first = buffer.getChar();
        System.out.println("first=" + first);
    }
}

Salida esperada:

JAVA
first=J

Un char de Java es una unidad de código UTF-16, y getChar() no decodifica una secuencia arbitraria de bytes UTF-8. Para texto almacenado como UTF-8, lea los bytes y decodifíquelos con un Charset como StandardCharsets.UTF_8. Para este ejemplo de ancho fijo, el tamaño del búfer es exactamente dos bytes por carácter, y la comprobación de bytes restantes garantiza que cada getChar() tenga dos bytes disponibles. rewind() entonces hace que la misma región sea legible de nuevo, permitiendo que la lectura final recupere el primer carácter.