Introduction détaillée aux exemples de code du type de tableau d'octets Java (byte[]) et des méthodes de conversion mutuelle de type int

L'éditeur suivant vous proposera un article sur la façon de convertir le type de tableau d'octets Java (byte[]) et le type int. L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Suivons l'éditeur et jetons un oeil

Le code est le suivant :

public class CommonUtils {
 //高位在前，低位在后
 public static byte[] int2bytes(int num){
 byte[] result = new byte[4];
 result[0] = (byte)((num >>> 24) & 0xff);//说明一
 result[1] = (byte)((num >>> 16)& 0xff );
 result[2] = (byte)((num >>> 8) & 0xff );
 result[3] = (byte)((num >>> 0) & 0xff );
 return result;
 }
 
 //高位在前，低位在后
 public static int bytes2int(byte[] bytes){
 int result = 0;
 if(bytes.length == 4){
  int a = (bytes[0] & 0xff) << 24;//说明二
  int b = (bytes[1] & 0xff) << 16;
  int c = (bytes[2] & 0xff) << 8;
  int d = (bytes[3] & 0xff);
  result = a | b | c | d;
 }
 return result;
 }
 
 public static void main(String[] args){
 int a = -64;
 System.out.println("-64="+Integer.toBinaryString(-64));
 byte[] bytes = CommonUtils.int2bytes(a);
 for(int i = 0 ; i<4 ; i++){
  System.out.println(bytes[i]);
 }
 a = CommonUtils.bytes2int(bytes);
 System.out.println(a);
 
 }
}

Les résultats en cours d'exécution sont les suivants :

-64=11111111111111111111111111000000
-1
-1
-1
-64
-64

Explication 1 :

java, le binaire est exprimé au format complément à deux <🎜. >-64 >>> ; Après 24 (décalage à droite non signé, bits hauts remplis de 0), il devient [00000000][00000000][00000000][11111111]

Après l'étape précédente résultat & 0xff, il est toujours [00000000][00000000] [00000000][11111111], puisque la valeur de 0xff est [00000000][00000000][00000000][11111111], le but de & 0xff est de conserver les 8 les plus bas bits inchangés, et les positions restantes sont 0

Ensuite, convertissez le résultat en type octet, conservez le bit bas, tronquez le bit haut et devenez [11111111]. le 0xff de l'étape précédente est en fait inutile, quel que soit le bit haut, à la fin sera tronqué

donc le résultat[0] est [11111111]=-1 et ainsi de suite :

result[1]为[11111111]=-1
result[2]为[11111111]=-1
result[3]为[11000000]=-64

octet[0] est [11111111]. sera converti en type int (Avant l'opération de décalage de bit, le type d'octet sera converti en type Int, si c'est un nombre positif, remplissez le bit haut avec 0, si c'est un nombre négatif, remplissez le haut bit avec 1), remplissez le bit haut avec 1, il devient [11111111][11111111][11111111][11111111]

Après le résultat de l'étape précédente & 0xff, il deviendra [ 00000000][00000000][00000000][11111111]

Ensuite, le résultat de l'étape précédente << 24 (décalage vers la gauche, bit bas rempli de 0 ), deviendra [11111111][00000000][ 00000000][00000000] = aDe la même manière, b, c, d

enfin a b | c d | voyez que afin de garantir que lorsque l'octet est converti en int, le remplissage n'affectera pas le résultat final de a | b | c | 🎜>La conversion entre short et byte[], et la conversion entre long et byte[] sont également similaires

PS :

[11111111][00000000][00000000][00000000] | 
[00000000][11111111][00000000][00000000] | 由于<<16位之前& 0xff，故保证b的最高8位都为0
[00000000][00000000][11111111][00000000] | 由于<<8位之前& 0xff，故保证c的最高16位都为0
[00000000][00000000][00000000][11000000] 由于& 0xff，故保证d的最高24为都为0
=[11111111][11111111][11111111][11000000] = -64

1 , le type int occupe 4 octets, tandis que le type byte n'occupe que 1 octet

Code original de -2 : 100000103, code inverse : Le code inverse d'un nombre positif est le même que son code original ;

Le bit de signe du complément du nombre négatif reste inchangé, et les bits restants sont inversés au niveau du bit

Le complément de 2 : 00000010

- Le complément de 2 : 111111014, complément : le complément d'un nombre positif est le même que son code d'origine le complément d'un nombre négatif est le complément du négatif ; numéro 1

Complément de -2 : 11111110