Comment puis-je traiter correctement les octets signés comme non signés en Java ?

Traiter les octets signés comme non signés en Java

Contexte du problème

La conversion d'octets signés en octets non signés peut être difficile en Java, car Java ne le fait pas nativement prend en charge les types d'octets non signés. Par conséquent, lorsque des valeurs d'octet signées sont reçues et interprétées comme telles, des problèmes d'intégrité des données peuvent survenir.

Tentative 1 : Conversion à l'aide d'une opération au niveau du bit

Pour résoudre ce problème, une solution courante suggère d'utiliser une opération au niveau du bit comme suit :

public static int unsignedToBytes(byte a) {
    int b = a & 0xFF;
    return b;
}

Cependant, cette méthode ne parvient pas à obtenir le résultat souhaité car la réaffectation de la valeur renvoyée à un type d'octet entraîne toujours une interprétation signée, ce qui conduit à la distorsion des données.

Solution : downcasting et interprétation manuels

La clé pour résoudre ce problème réside dans la compréhension que si les primitives en Java sont signées, leur représentation en mémoire ne l'est pas. Voici une solution modifiée qui interprète l'octet comme une valeur non signée en le downcastant explicitement :

int i = 200; // 0000 0000 0000 0000 0000 0000 1100 1000 (200)
byte b = (byte) i; // 1100 1000 (-56 by Java specification, 200 by convention)

/*
 * When b is cast back to int, sign extension leads to:
 * 1111 1111 1111 1111 1111 1111 1100 1000 (-56)
 *
 * However, we choose to interpret this as +200 instead.
 */
System.out.println(b); // "-56"

/*
 * To eliminate sign extension, we perform a bitwise AND with 0xFF:
 * 1111 1111 1111 1111 1111 1111 1100 1000 (the int)
 * &
 * 0000 0000 0000 0000 0000 0000 1111 1111 (0xFF)
 * =======================================
 * 0000 0000 0000 0000 0000 0000 1100 1000 (200)
 */
System.out.println(b & 0xFF); // "200"

Dans l'exemple ci-dessus, nous downcastons un entier i en un octet b, ce qui entraîne que la valeur est interprétée comme négative. selon les spécifications d'octets signés de Java. Cependant, en effectuant manuellement un AND au niveau du bit avec 0xFF, nous effaçons efficacement l'extension de signe et récupérons la valeur non signée correcte.

En utilisant cette technique, vous pouvez travailler de manière transparente avec des valeurs d'octets non signés en Java, garantissant ainsi une gestion précise des données et interprétation dans les limites de la langue.

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!