Comment convertir un tableau d'octets en un long en Java ?

Conversion de tableaux d'octets en tableaux longs en Java : un guide complet

La conversion entre les types de données longs et les tableaux d'octets est une tâche fondamentale dans la programmation Java , en particulier lors de l'échange de données sur des réseaux ou de leur stockage au format binaire. Cet article décrit les différentes méthodes pour effectuer cette conversion efficacement.

Conversion de tableau d'octets longs

Pour convertir une valeur longue en tableau d'octets, vous pouvez utiliser ce qui suit approche :

<code class="java">public byte[] longToBytes(long x) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.putLong(x);
    return buffer.array();
}</code>

Dans ce code, un objet ByteBuffer est alloué avec une taille égale au nombre d'octets requis pour représenter une valeur longue. La méthode putLong est utilisée pour écrire la valeur longue dans le tampon, et enfin, la méthode array récupère la représentation du tableau d'octets sous-jacente.

Conversion du tableau d'octets en long

Pour effectuer la conversion inverse, vous pouvez utiliser le code suivant :

<code class="java">public long bytesToLong(byte[] bytes) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.put(bytes);
    buffer.flip(); // Flip the buffer to make it ready for reading
    return buffer.getLong();
}</code>

Ici, un objet ByteBuffer est à nouveau utilisé, cette fois pour envelopper le tableau d'octets fourni. La méthode put est utilisée pour copier les octets dans le tampon, puis retourner le tampon pour indiquer qu'il est maintenant prêt à être lu. Enfin, la méthode getLong récupère la valeur longue du tampon.

Éviter la création répétée de ByteBuffer

Pour les scénarios où plusieurs conversions seront effectuées, il est plus efficace d'éviter de créer de nouveaux objets ByteBuffer pour chaque conversion. Ceci peut être réalisé en encapsulant le processus dans une classe :

<code class="java">public class ByteUtils {
    private static ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);

    public static byte[] longToBytes(long x) {
        buffer.putLong(0, x);
        return buffer.array();
    }

    public static long bytesToLong(byte[] bytes) {
        buffer.put(bytes, 0, bytes.length);
        buffer.flip();
        return buffer.getLong();
    }
}</code>

Dans ce cas, un seul objet ByteBuffer est partagé entre toutes les conversions, minimisant ainsi la surcharge de création d'objet.

Conclusion

Les méthodes décrites dans cet article fournissent des moyens efficaces et fiables de convertir entre des valeurs longues et des tableaux d'octets en Java. Que vous optiez pour l'approche directByteBuffer ou que vous utilisiez le wrapper ByteUtils, vous pouvez gérer ces conversions en toute confiance dans vos applications.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!