Detaillierte Einführung in Codebeispiele für gegenseitige Konvertierungsmethoden vom Java-Byte-Array-Typ (Byte[]) und vom Typ Int

Der folgende Editor bringt Ihnen einen Artikel über die Konvertierung des Java-Byte-Array-Typs (Byte[]) und des Int-Typs. Der Herausgeber findet es ziemlich gut, deshalb werde ich es jetzt mit Ihnen teilen und es allen als Referenz geben. Folgen wir dem Editor und werfen wir einen Blick darauf.

Der Code lautet wie folgt:

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);
 
 }
}

Die Laufergebnisse sind wie folgt:

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

Erklärung 1:

-64 wird in binären Originalcode konvertiert als [10000000][00000000][00000000][01000000]

Konvertieren Originalcode in Komplementcode umwandeln als [11111111 ][11111111][11111111][11000000], was mit der Konsolenausgabe identisch ist. Sie können sehen, dass Binärcode in Java im Zweierkomplementformat <🎜 ausgedrückt wird >

-64 >>> ; Nach 24 (vorzeichenlose Rechtsverschiebung, hohe Bits mit 0 gefüllt) wird es zu [00000000][00000000][00000000][11111111]

Nach dem vorherigen Schritt Ergebnis & 0xff, es ist immer noch [00000000][00000000] [00000000][11111111], da der Wert von 0xff [00000000][00000000][00000000][11111111] ist, besteht der Zweck von & 0xff darin, die niedrigsten 8 beizubehalten Bits unverändert und die verbleibenden Positionen sind 0

Dann wird das Ergebnis in den Byte-Typ konvertiert, wobei die niedrigen Bits beibehalten und die hohen Bits abgeschnitten werden, und wird zu [11111111]. >das 0xff im vorherigen Schritt ist eigentlich unnötig, egal wie hoch die Bits sind, am Ende wird es abgeschnitten

, sodass result[0] [11111111]=-1< ist 🎜> und so weiter:

Hinweis 2:

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

Byte[0] ist [11111111]. ] wird in den Typ int konvertiert ( Vor der Bitverschiebungsoperation wird der Bytetyp in den Typ Int konvertiert. Wenn es sich um eine positive Zahl handelt, füllen Sie das High-Bit mit 0, wenn es eine negative Zahl ist, füllen Sie das High-Bit mit 1), Füllen Sie das High-Bit mit 1, es wird zu [11111111][11111111][11111111][11111111]

Nach dem Ergebnis des vorherigen Schritts & 0xff wird es [00000000][00000000][00000000][11111111]

Dann wird das Ergebnis des vorherigen Schritts << 24 (nach links verschieben, unteres Bit mit 0 gefüllt) zu [11111111][00000000] [00000000][00000000] = aAuf die gleiche Weise ist b, c, d

endlich a |. c | Sie können sehen, dass

& 0xff nicht erforderlich ist, wenn Byte in int konvertiert wird

Die Konvertierung zwischen short und byte[] und die Konvertierung zwischen long und byte[] sind ebenfalls ähnlich

[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

PS:

1, der int-Typ belegt 4 Bytes, während der Byte-Typ nur 1 Byte belegt

2, der ursprüngliche Code: Das höchste Bit ist das Vorzeichenbit, und die restlichen Bits werden zur Darstellung der numerischen Größe verwendet

Originalcode von 2: 00000010Originalcode von -2: 10000010

3, Umkehrcode:

Der Umkehrcode einer positiven Zahl ist derselbe wie ihr Originalcode ;

Das Vorzeichenbit des Einserkomplements negativer Zahlen bleibt unverändert und die restlichen Bits werden bitweise invertiert

Das Einserkomplement von 2: 00000010

- Das Komplement von 2: 11111101

4, Komplement: Das Komplement einer positiven Zahl ist dasselbe wie sein Originalcode; das Komplement einer negativen Zahl ist das Komplement der negativen Zahl + 1

2 Komplementcode: 00000010

-2 Komplementcode: 11111110

Das Obige ist eine detaillierte Einführung in die Codebeispiele des Java-Byte-Arrays Typ (Byte []) und Int-Typ gegenseitige Konvertierungsmethode, mehr Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!