Comment convertir une valeur longue en un tableau d'octets et inversement en Java ?

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 en Byte Array

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

Cette méthode utilise la classe ByteBuffer pour créer un tampon de taille Long.BYTES, qui est le 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

<code class="java">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();
}</code>

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 class :

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

Cette classe 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'endianité

Notez 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, pensez à utiliser une bibliothèque comme Guava ou Apache Commons, qui offrent des solutions plus complètes et efficaces.

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!