Una buena forma de acceder a palabras mixtas de 8/16/32 bits

Tengo una gran cantidad de datos binarys en la memory y necesito leer / escribir desde direcciones alineadas por byte random. Sin embargo, a veces necesito leer / escribir palabras de 8 bits, a veces (big-endian) palabras de 16 bits, y algunas veces (big-endian) de 32 bits.

Existe la ingenua solución de representar los datos como ByteArray e implementar las lecturas / escrituras de 16/32 bits a mano:

 class Blob (val image: ByteArray, var ptr: Int = 0) { fun readWord8(): Byte = image[ptr++] fun readWord16(): Short { val hi = readWord8().toInt() and 0xff val lo = readWord8().toInt() and 0xff return ((hi shl 8) or lo).toShort() } fun readWord32(): Int { val hi = readWord16().toLong() and 0xffff val lo = readWord16().toLong() and 0xffff return ((hi shl 16) or lo).toInt() } } 

(y de manera similar para writeWord8 / writeWord16 / writeWord32 ).

¿Hay una mejor manera de hacer esto? Parece tan ineficiente hacer todo este byte-shuffling cuando Java ya usa una representación big-endian dentro de …

Para reiterarlo, necesito tanto acceso de lectura y escritura , búsquedas aleatorias , y acceso de 8/16/32 bits a las palabras de gran tamaño.

Puede usar Java NIO ByteBuffer :

 val array = ByteArray(100) val buffer = ByteBuffer.wrap(array) val b = buffer.get() val s = buffer.getShort() val i = buffer.getInt() buffer.put(0.toByte()) buffer.putShort(0.toShort()) buffer.putInt(0) buffer.position(10) 

El order de bytes de un ByteBuffer recién creado es BIG_ENDIAN , pero aún se puede cambiar con la function de order(ByteOrder) .

Además, utilice ByteBuffer.allocate(size) y buffer.array() si desea evitar la creación de un ByteArray explícita.

Más sobre el uso de ByteBuffer : vea esta pregunta .