int和byte数组相互转换详解

转换之前我们需要了解各种进制之间的关系，不太了解的可以先看下计算机组成原理和体系 这篇文章

byte

byte是字节的意思，一个字节等于8位，范围是 0000 0000 ~ 1111 1111(十六进制：0x0~0xff),总共包含256个数。
有符号的byte表示的范围为：-128~127
无符号的byte表示的范围为：0~255

java中默认的是有符号的byte，当我们需要与硬件交互时，需要转换为无符号的byte。

一、int转byte数组

1、当value小于等于255时，转换为1个字节，1个字节能表示无符号的范围为0 ~ $2^8$-1，即0~255

例如：
int value = 246 转换成二进制为 1111 0110

$(246{)}_{10}$ →$(11110110{)}_2$

转换成二进制为8位，占用1个字节

int value =246
byte[] bytes= new byte[1];
bytes[0] =(byte) (value & 0xFF);
1
2
3

bytes[0]

(byte) (value & 0xFF)：这是一个与操作，0xFF是十六进制，转换成二进制为：1111 1111，转换成十进制为：255，当value和0xFF按位与运算时，得到的是value的最后8位（低8位），其余高位将被清零。这样做可以确保结果只包含原始数值的低8位，模拟出无符号整数的行为。

bytes[0]的二进制就为：1111 0110，转换成十六进制为：0xF6

bytes发送到硬件设备，硬件设备接收到的就是0xF6

2、当value大于255时，转换为2个字节，2个字节能表示无符号的范围为0 ~ $2^{16}$-1，即0~65535

例如：
int value = 3658，转换成二进制为：1110 0100 1010

$(3658{)}_{10}$ →$(111001001010{)}_2$

转换成二进制超过8位，占用16位，占用2个字节

int value =3658
byte[] bytes= new byte[2];
bytes[0] =(byte) ((value >> 8) & 0xFF);
bytes[1] =(byte) (value & 0xFF);
1
2
3
4

bytes[0]

(byte) ((value >> 8) & 0xFF)：>>是右移操作，(value >> 8) 是先将value的所有位向右移动8位，移动后的左边（高位）会填充0（因为是无符号右移）。
$(3658{)}_{10}$ →$(111001001010{)}_2$，(3658 >> 8)得到的是$(000000001110{)}_2$

& 0xFF：是按位与运算，得到最后8位，$(000000001110{)}_2$ & 0xFF 得到的是$(00001110{)}_2$

所以bytes[0]的二进制值为：0000 1110，转换成十六进制为：0x0E

bytes[1]

(byte) (value & 0xFF) ：是按位与运算，得到最后8位，$(111001001010{)}_2$ & 0xFF得到的是$(01001010{)}_2$

所以bytes[1]的二进制值为：0100 1010，转换成十六进制为：0x4A

bytes发送到硬件设备，硬件设备接收到的就是0x0E4A

3、当value大于65535时，转换为3个字节，3个字节能表示无符号的范围为0 ~ $2^{24}$-1，即0~16777215

例如：
int value = 5623658，转换成二进制为：0101 0101 1100 1111 0110 1010

$(5623658{)}_{10}$ →$(010101011100111101101010{)}_2$

转换成二进制超过16位，占用24位，占用3个字节

int value =5623658
byte[] bytes= new byte[3];
bytes[0] =(byte) ((value >> 16) & 0xFF);
bytes[1] =(byte) ((value >> 8) & 0xFF);
bytes[2] =(byte) (value & 0xFF);
1
2
3
4
5

bytes[0]

(byte) ((value >> 16) & 0xFF)：>>是右移操作，(value >> 16) 是先将value的所有位向右移动16位，移动后的左边（高位）会填充0（因为是无符号右移）。
$(5623658{)}_{10}$ →$(010101011100111101101010{)}_2$，(5623658>> 16)得到的是$(000000000000000001010101{)}_2$

& 0xFF：是按位与运算，得到最后8位，$(000000000000000001010101{)}_2$& 0xFF 得到的是$(01010101{)}_2$

所以bytes[0]的二进制值为：0101 0101，转换成十六进制为：0x55

bytes[1]

(byte) ((value >> 8) & 0xFF)：>>是右移操作，(value >> 8) 是先将value的所有位向右移动8位，移动后的左边（高位）会填充0（因为是无符号右移）。
$(5623658{)}_{10}$ →$(010101011100111101101010{)}_2$，(5623658>> 8)得到的是$(000000000101010111001111{)}_2$

& 0xFF：是按位与运算，得到最后8位，$(000000000101010111001111{)}_2$ & 0xFF 得到的是$(11001111{)}_2$

所以bytes[0]的二进制值为：1100 1111，转换成十六进制为：0xCF

bytes[2]

(byte) (value & 0xFF) ：是按位与运算，得到最后8位，$(010101011100111101101010{)}_2$ & 0xFF得到的是$(01101010{)}_2$

所以bytes[2]的二进制值为：0110 1010，转换成十六进制为：0x6A

bytes发送到硬件设备，硬件设备接收到的就是0x55CF6A

4、当value大于16777215时，转换为4个字节，4个字节能表示无符号的范围为0 ~ $2^{32}$-1，即0~4294967295

int在java中是有符号数，int的取值范围为-$2^{31}$ ~ $2^{31}$-1，即-2147483648~2147483648

例如：
int value = 316777215，转换成二进制为：0001 0010 1110 0001 1010 0010 1111 1111

$(316777215{)}_{10}$ →$(00010010111000011010001011111111{)}_2$

转换成二进制超过24位，占用32位，占用4个字节

int value =316777215
byte[] bytes= new byte[4];
bytes[0] =(byte) ((value >> 24) & 0xFF);
bytes[1] =(byte) ((value >> 16) & 0xFF);
bytes[2] =(byte) ((value >> 8) & 0xFF);
bytes[3] =(byte) (value & 0xFF);
1
2
3
4
5
6

bytes[0]

(byte) ((value >> 24) & 0xFF)：>>是右移操作，(value >> 24) 是先将value的所有位向右移动24位，移动后的左边（高位）会填充0（因为是无符号右移）。
$(316777215{)}_{10}$ →$(00010010111000011010001011111111{)}_2$，(316777215>> 24)得到的是$(000000000000000000000000000010010{)}_2$

& 0xFF：是按位与运算，得到最后8位，$(000000000000000000000000000010010{)}_2$ & 0xFF 得到的是$(00010010{)}_2$

所以bytes[0]的二进制值为：0001 0010，转换成十六进制为：0x12

bytes[1]

(byte) ((value >> 16) & 0xFF)：>>是右移操作，(value >> 16) 是先将value的所有位向右移动16位，移动后的左边（高位）会填充0（因为是无符号右移）。
$(316777215{)}_{10}$ →$(00010010111000011010001011111111{)}_2$，(316777215>> 16)得到的是$(000000000000000000001001011100001{)}_2$

& 0xFF：是按位与运算，得到最后8位，$(000000000000000000001001011100001{)}_2$ & 0xFF 得到的是$(11100001{)}_2$

所以bytes[0]的二进制值为：1110 0001，转换成十六进制为：0xE1

bytes[2]

(byte) ((value >> 8) & 0xFF)：>>是右移操作，(value >> 8) 是先将value的所有位向右移动8位，移动后的左边（高位）会填充0（因为是无符号右移）。
$(316777215{)}_{10}$ →$(00010010111000011010001011111111{)}_2$，(316777215>> 8)得到的是$(000000000000100101110000110100010{)}_2$

& 0xFF：是按位与运算，得到最后8位，$(000000000000100101110000110100010{)}_2$ & 0xFF 得到的是$(10100010{)}_2$

所以bytes[0]的二进制值为：1010 0010，转换成十六进制为：0xA2

bytes[3]

(byte) (value & 0xFF) ：是按位与运算，得到最后8位，$(00010010111000011010001011111111{)}_2$ & 0xFF得到的是$(11111111{)}_2$

所以bytes[2]的二进制值为：1111 1111，转换成十六进制为：0xFF

bytes发送到硬件设备，硬件设备接收到的就是0x12E1A2FF

总结：int转byte数组

将int数值转换为占四个字节的byte数组，如下

    /**
     * 将int数值转换为占四个字节的byte数组，(高位在前，低位在后的顺序)。
     *
     * @param value 要转换的int值
     * @return byte数组
     */
    public static byte[] intToBytes(int value) {
        byte[] src = new byte[4];
        src[0] = (byte) ((value >> 24) & 0xFF);
        src[1] = (byte) ((value >> 16) & 0xFF);
        src[2] = (byte) ((value >> 8) & 0xFF);
        src[3] = (byte) (value & 0xFF);
        return src;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

二、byte数组转int

1、当byte数组的长度为1时，占用1个字节

例如：

byte[] bytes= new byte[]{(byte) 0xF6};
1

0xF6 转换成二进制为 1111 0110

byte[] bytes= new byte[]{(byte) 0xF6};
int value = 	bytes[0]  & 0xFF;
1
2

(byte) (bytes[0] & 0xFF)：这是一个与操作，0xFF是十六进制，转换成二进制为：1111 1111，转换成十进制为：255，当bytes[0]和0xFF按位与运算时，得到的是bytes[0]的最后8位（低8位），其余高位将被清零。

value的二进制就为：1111 0110，转换成十进制为：246

所以byte[] bytes= new byte[]{(byte) 0xF6}；bytes转换位int就为：246

2、当byte数组的长度为2时，占用2个字节

例如：

byte[] bytes= new byte[]{(byte) 0x0E,(byte) 0x4A};
1

0x0E 转换成二进制为 0000 1110

0x4A 转换成二进制为 0100 1010

byte[] bytes= new byte[]{(byte) 0x0E,(byte) 0x4A};
int value = ((bytes[0] & 0xFF) << 8)  |  (bytes[1] & 0xFF)
1
2

bytes[0] & 0xFF ：操作确保这个字节被当作无符号数处理
<< 8：这是一个左移位操作。如果 (bytes[0] & 0xFF) 得到了一个无符号的8位数值，那么 << 8 将这个数值向左移动8位。

((bytes[0] & 0xFF) << 8) 得到 0000 1110 0000 0000

(bytes[1] & 0xFF：操作确保这个字节被当作无符号数处理

(bytes[1] & 0xFF得到： 0100 1010

| 是按位或操作，它将左移后的第一个字节和第二个字节（同样经过位与操作以确保无符号处理）的值合并在一起，形成一个新的数值。

所以value的二进制为：0000 1110 0100 1010 ，转换成int为：3658

3、当byte数组的长度为3时，占用3个字节

例如：

byte[] bytes= new byte[]{(byte) 0x55,(byte) 0xCF,(byte) 0x6A};
1

0x55 转换成二进制为 0101 0101

0xCF 转换成二进制为 1100 1111

0x6A 转换成二进制为 0110 1010

byte[] bytes= new byte[]{(byte) 0x55,(byte) 0xCF,(byte) 0x6A};
int value = ((bytes[0] & 0xFF) << 16)  | ((bytes[1] & 0xFF) << 8)  |  (bytes[2] & 0xFF)
1
2

bytes[0] & 0xFF ：操作确保这个字节被当作无符号数处理
<< 16：这是一个左移位操作。如果 (bytes[0] & 0xFF) 得到了一个无符号的8位数值，那么 << 16 将这个数值向左移动16位，低位补0。

((bytes[0] & 0xFF) << 16) 得到 0101 0101 0000 0000 0000 0000

bytes[1] & 0xFF ：操作确保这个字节被当作无符号数处理
<< 8：这是一个左移位操作。如果 (bytes[0] & 0xFF) 得到了一个无符号的8位数值，那么 << 8 将这个数值向左移动8位，低位补0。

((bytes[1] & 0xFF) << 8) 得到 1100 1111 0000 0000

(bytes[2] & 0xFF：操作确保这个字节被当作无符号数处理

(bytes[2] & 0xFF得到： 0110 1010

所以value的二进制为：0101 0101 1100 1111 0110 1010 ，转换成int为：5623658

4、当byte数组的长度为4时，占用4个字节

例如：0x12E1A2FF

byte[] bytes= new byte[]{(byte) 0x12,(byte) 0xE1,(byte) 0xA2,(byte) 0xFF};
1

0x12 转换成二进制为 0001 0010

0xE1 转换成二进制为 1110 0001

0xA2 转换成二进制为 1010 0010

0xFF 转换成二进制为 1111 1111

byte[] bytes= new byte[]{(byte) 0x12,(byte) 0xE1,(byte) 0xA2,(byte) 0xFF};
int value = ((bytes[0] & 0xFF) << 24)  | ((bytes[0] & 0xFF) << 16)  
| ((bytes[1] & 0xFF) << 8)  |  (bytes[2] & 0xFF)
1
2
3

bytes[0] & 0xFF ：操作确保这个字节被当作无符号数处理
<< 24：这是一个左移位操作。如果 (bytes[0] & 0xFF) 得到了一个无符号的8位数值，那么 << 24 将这个数值向左移动24位，低位补0。

((bytes[0] & 0xFF) << 24) 得到0001 0010 0000 0000 0000 0000 0000 0000

bytes[1] & 0xFF ：操作确保这个字节被当作无符号数处理
<< 16：这是一个左移位操作。如果 (bytes[0] & 0xFF) 得到了一个无符号的8位数值，那么 << 16 将这个数值向左移动16位，低位补0。

((bytes[1] & 0xFF) << 16) 得到 1110 0001 0000 0000 0000 0000

bytes[2] & 0xFF ：操作确保这个字节被当作无符号数处理
<< 8：这是一个左移位操作。如果 (bytes[0] & 0xFF) 得到了一个无符号的8位数值，那么 << 8 将这个数值向左移动8位，低位补0。

((bytes[2] & 0xFF) << 8) 得到 1010 0010 0000 0000

(bytes[3] & 0xFF：操作确保这个字节被当作无符号数处理

(bytes[3] & 0xFF得到： 1111 1111

| 是按位或操作，将4个字节拼接成一个新的数值

所以value的二进制为：0001 0010 1110 0001 1010 0010 1111 1111，转换成int为：316777215

总结：byte数组转int

将占四个字节的byte数组转换为int数值

    /**
     * 将占四个字节的byte数组转换为int数值，(高位在前，低位在后的顺序)。
     *
     * @param src 占四个字节的byte数组
     * @return int数值
     */
    public static int bytesToInt(byte[] src) {
        int value;
        value = (((src[0] & 0xFF) << 24)
                | ((src[1] & 0xFF) << 16)
                | ((src[2] & 0xFF) << 8)
                | (src[3] & 0xFF));
        return value;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

    /**
     * 将字节数组的一部分转换为整数。
     *
     * @param bytes  字节数组
     * @param start  起始位置（包含）
     * @param length 要转换的字节长度
     * @return 转换后的整数
     */
    public static int byteArrayToInt(byte[] bytes, int start, int length) {
        int result = 0;
        for (int i = start; i < start + length; i++) {
            result = result | ((bytes[i] & 0xFF) << ((start + length - i - 1) * 8));
        }
        return result;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15