Convertir un tableau d'octets en nombre entier en Java et vice versa

Je souhaite stocker des données dans des tableaux d'octets en Java. Fondamentalement, juste des nombres qui peuvent prendre jusqu'à 2 octets par nombre.

J'aimerais savoir comment je peux convertir un entier en un tableau d'octets de 2 octets et vice versa. J'ai trouvé beaucoup de solutions sur Google, mais la plupart n'expliquent pas ce qui se passe dans le code. Il y a beaucoup de choses changeantes que je ne comprends pas vraiment, alors j'apprécierais une explication de base.

Utilisez les classes trouvées dans l' java.nioespace de noms, en particulier le ByteBuffer. Il peut faire tout le travail pour vous.

byte[] arr = { 0x00, 0x01 };
ByteBuffer wrapped = ByteBuffer.wrap(arr); // big-endian by default
short num = wrapped.getShort(); // 1

ByteBuffer dbuf = ByteBuffer.allocate(2);
dbuf.putShort(num);
byte[] bytes = dbuf.array(); // { 0, 1 }

byte[] toByteArray(int value) {
     return  ByteBuffer.allocate(4).putInt(value).array();
}

byte[] toByteArray(int value) {
    return new byte[] { 
        (byte)(value >> 24),
        (byte)(value >> 16),
        (byte)(value >> 8),
        (byte)value };
}

int fromByteArray(byte[] bytes) {
     return ByteBuffer.wrap(bytes).getInt();
}
// packing an array of 4 bytes to an int, big endian, minimal parentheses
// operator precedence: <<, &, | 
// when operators of equal precedence (here bitwise OR) appear in the same expression, they are evaluated from left to right
int fromByteArray(byte[] bytes) {
     return bytes[0] << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | (bytes[3] & 0xFF);
}

// packing an array of 4 bytes to an int, big endian, clean code
int fromByteArray(byte[] bytes) {
     return ((bytes[0] & 0xFF) << 24) | 
            ((bytes[1] & 0xFF) << 16) | 
            ((bytes[2] & 0xFF) << 8 ) | 
            ((bytes[3] & 0xFF) << 0 );
}

Lors du regroupement d'octets signés dans un entier, chaque octet doit être masqué car il est étendu par signe à 32 bits (plutôt que zéro) en raison de la règle de promotion arithmétique (décrite dans JLS, Conversions et Promotions).

Il y a un casse-tête intéressant lié à cela décrit dans Java Puzzlers ("Un grand plaisir dans chaque octet") par Joshua Bloch et Neal Gafter. Lors de la comparaison d'une valeur d'octet à une valeur int, l'octet est étendu par signe à un int, puis cette valeur est comparée à l'autre int

byte[] bytes = (…)
if (bytes[0] == 0xFF) {
   // dead code, bytes[0] is in the range [-128,127] and thus never equal to 255
}

Notez que tous les types numériques sont signés en Java, à l'exception du fait que char est un type entier non signé 16 bits.

Vous pouvez également utiliser BigInteger pour les octets de longueur variable. Vous pouvez le convertir en long, int ou short, selon vos besoins.

new BigInteger(bytes).intValue();

ou pour désigner la polarité:

new BigInteger(1, bytes).intValue();

Pour récupérer des octets simplement:

new BigInteger(bytes).toByteArray()

Une implémentation de base serait quelque chose comme ceci:

public class Test {
    public static void main(String[] args) {
        int[] input = new int[] { 0x1234, 0x5678, 0x9abc };
        byte[] output = new byte[input.length * 2];

        for (int i = 0, j = 0; i < input.length; i++, j+=2) {
            output[j] = (byte)(input[i] & 0xff);
            output[j+1] = (byte)((input[i] >> 8) & 0xff);
        }

        for (int i = 0; i < output.length; i++)
            System.out.format("%02x\n",output[i]);
    }
}

Afin de comprendre les choses, vous pouvez lire cet article WP: http://en.wikipedia.org/wiki/Endianness

Le code source ci-dessus sera généré 34 12 78 56 bc 9a. Les 2 premiers octets ( 34 12) représentent le premier entier, etc. Le code source ci-dessus encode les entiers au format little endian.

/** length should be less than 4 (for int) **/
public long byteToInt(byte[] bytes, int length) {
        int val = 0;
        if(length>4) throw new RuntimeException("Too big to fit in int");
        for (int i = 0; i < length; i++) {
            val=val<<8;
            val=val|(bytes[i] & 0xFF);
        }
        return val;
    }

Quelqu'un avec une exigence où ils doivent lire à partir de bits, disons que vous devez lire à partir de seulement 3 bits mais vous avez besoin d'un entier signé, puis utilisez ce qui suit:

data is of type: java.util.BitSet

new BigInteger(data.toByteArray).intValue() << 32 - 3 >> 32 - 3

Le nombre magique 3peut être remplacé par le nombre de bits (et non d'octets) que vous utilisez.

Comme souvent, la goyave a ce dont vous avez besoin.

Pour passer du tableau d'octets à int:, Ints.fromBytesArraydoc ici

Pour passer du tableau int au tableau d'octets:, Ints.toByteArraydoc ici

je pense que c'est le meilleur mode de diffusion en int

   public int ByteToint(Byte B){
        String comb;
        int out=0;
        comb=B+"";
        salida= Integer.parseInt(comb);
        out=out+128;
        return out;
    }

premier octet de conversion en chaîne

comb=B+"";

la prochaine étape est de passer à un int

out= Integer.parseInt(comb);

mais l'octet est en rage de -128 à 127 pour cette raison, je pense qu'il vaut mieux utiliser rage 0 à 255 et il vous suffit de faire ceci:

out=out+256;