Obtient un tableau d'octets à partir d'un ByteBuffer en java

Est-ce la méthode recommandée pour obtenir les octets du ByteBuffer

ByteBuffer bb =..

byte[] b = new byte[bb.remaining()]
bb.get(b, 0, b.length);

Ça dépend de ce que tu veux faire.

Si vous voulez récupérer les octets restants (entre la position et la limite), alors ce que vous avez fonctionnera. Vous pouvez aussi simplement faire:

ByteBuffer bb =..

byte[] b = new byte[bb.remaining()];
bb.get(b);

qui est équivalent selon les javadocs ByteBuffer.

Notez que bb.array () n'honore pas la position des byte-buffers, et pourrait être encore pire si le bytebuffer sur lequel vous travaillez est une tranche d'un autre tampon.

C'est à dire

byte[] test = "Hello World".getBytes("Latin1");
ByteBuffer b1 = ByteBuffer.wrap(test);
byte[] hello = new byte[6];
b1.get(hello); // "Hello "
ByteBuffer b2 = b1.slice(); // position = 0, string = "World"
byte[] tooLong = b2.array(); // Will NOT be "World", but will be "Hello World".
byte[] world = new byte[5];
b2.get(world); // world = "World"

Ce n'est peut-être pas ce que vous avez l'intention de faire.

Si vous ne voulez vraiment pas copier le tableau d'octets, une solution de contournement pourrait être d'utiliser le arrayOffset () + restant () du tampon d'octets, mais cela ne fonctionne que si l'application prend en charge l'index + la longueur des tampons d'octets. Besoins.

Aussi simple que cela

  private static byte[] getByteArrayFromByteBuffer(ByteBuffer byteBuffer) {
    byte[] bytesArray = new byte[byteBuffer.remaining()];
    byteBuffer.get(bytesArray, 0, bytesArray.length);
    return bytesArray;
}

final ByteBuffer buffer;
if (buffer.hasArray()) {
    final byte[] array = buffer.array();
    final int arrayOffset = buffer.arrayOffset();
    return Arrays.copyOfRange(array, arrayOffset + buffer.position(),
                              arrayOffset + buffer.limit());
}
// do something else

Si l'on ne sait rien de l'état interne du ByteBuffer (Direct) donné et veut récupérer tout le contenu du buffer, on peut l'utiliser:

ByteBuffer byteBuffer = ...;
byte[] data = new byte[byteBuffer.capacity()];
((ByteBuffer) byteBuffer.duplicate().clear()).get(data);

C'est un moyen simple d'obtenir un octet [], mais une partie du but d'utiliser un ByteBuffer est d'éviter d'avoir à créer un octet []. Peut-être pouvez-vous obtenir tout ce que vous vouliez obtenir de l'octet [] directement du ByteBuffer.