Conversion de Long en tableau d'octets et inversement en Java

En Java, conversion d'un type de données primitif long en tableau d'octets (byte[] ) et vice versa est une tâche courante pour diverses opérations, telles que l'envoi de données via une connexion TCP. Voici une solution complète pour réaliser cette conversion :

Long to Byte Array

public byte[] longToBytes(long x) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.putLong(x);
    return buffer.array();
}

Cette méthode utilise la classe ByteBuffer pour créer un tampon de taille Long.BYTES, qui correspond 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 la méthode array() renvoie le tableau d'octets sous-jacent représentant la valeur longue.

Byte Array to Long

public long bytesToLong(byte[] bytes) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.put(bytes);
    buffer.flip(); // Flip the buffer to prepare for reading
    return buffer.getLong();
}

Pour reconvertir le tableau d'octets en un tableau long, un nouveau ByteBuffer est créé et chargé avec le tableau d'octets donné. La méthode flip() est utilisée pour préparer le tampon à la lecture. Enfin, la méthode getLong() lit la valeur longue dans le tampon.

Encapsulation dans une classe d'assistance

Pour plus de commodité, les méthodes de conversion peuvent être encapsulées dans un utilitaire. classe :

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(); // Flip the buffer to prepare for reading
        return buffer.getLong();
    }
}

Cette classe d'utilitaire fournit un moyen simple d'effectuer la conversion sans avoir à créer et gérer des instances ByteBuffer à chaque fois.

Considérations sur l'endianisme

Remarque que la classe ByteBuffer utilise l'endianité native du système. Si une compatibilité multiplateforme est requise, des considérations supplémentaires concernant la gestion de l'endianisme peuvent être nécessaires.

Solution alternative : utilisation de bibliothèques

Bien que les solutions Java natives fournies ci-dessus soient adéquates, ils peuvent devenir fastidieux dans certains scénarios. Pour les besoins de conversion de données complexes ou étendus, envisagez d'utiliser une bibliothèque comme Guava ou Apache Commons, qui fournissent des solutions plus complètes et efficaces.