qidao123.com技术社区-IT企服评测·应用市场»论坛 › 虚拟化.超融合.云计算 › 虚拟化与私有云 › int和byte数组相互转换详解

int和byte数组相互转换详解

[复制链接]
发表于 昨天 13:48 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

×
转换之前我们必要相识各种进制之间的关系，不太相识的可以先看下盘算机构成原理和体系 这篇文章
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                                  2^{8}               28-1，即0~255

比方：
int value = 246 转换成二进制为 1111 0110
                               (                      246                               )                         10                                  (246)_{10}               (246)10​ →                              (                      1111                                             0110                               )                         2                                  (1111\ 0110)_2               (1111 0110)2​
转换成二进制为8位，占用1个字节
  1. int value =246
  2. byte[] bytes= new byte[1];
  3. bytes[0] =(byte) (value & 0xFF);
复制代码
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                                  2^{16}               216-1，即0~65535

比方：
int value = 3658，转换成二进制为：1110 0100 1010
                               (                      3658                               )                         10                                  (3658)_{10}               (3658)10​ →                              (                      1110                                             0100                                             1010                               )                         2                                  (1110\ 0100\ 1010)_2               (1110 0100 1010)2​
转换成二进制高出8位，占用16位，占用2个字节
  1. int value =3658
  2. byte[] bytes= new byte[2];
  3. bytes[0] =(byte) ((value >> 8) & 0xFF);
  4. bytes[1] =(byte) (value & 0xFF);
复制代码
bytes[0]

   (byte) ((value >> 8) & 0xFF)：>>是右移利用，(value >> 8) 是先将value的全部位向右移动8位，移动后的左边（高位）会添补0（由于是无符号右移）。
                                    (                         3658                                   )                            10                                       (3658)_{10}                  (3658)10​ →                                   (                         1110                                                   0100                                                   1010                                   )                            2                                       (1110\ 0100\ 1010)_2                  (1110 0100 1010)2​，(3658 >> 8)得到的是                                   (                         0000                                                   0000                                                   1110                                   )                            2                                       (0000\ 0000\ 1110)_2                  (0000 0000 1110)2​
  & 0xFF：是按位与运算，得到末了8位，                              (                      0000                                             0000                                             1110                               )                         2                                  (0000\ 0000\ 1110)_2               (0000 0000 1110)2​ & 0xFF 得到的是                              (                      0000                                             1110                               )                         2                                  (0000\ 1110)_2               (0000 1110)2​
   以是bytes[0]的二进制值为：0000 1110，转换成十六进制为：0x0E
  bytes[1]

(byte) (value & 0xFF) ：是按位与运算，得到末了8位，                              (                      1110                                             0100                                             1010                               )                         2                                  (1110\ 0100\ 1010)_2               (1110 0100 1010)2​ & 0xFF得到的是                              (                      0100                                             1010                               )                         2                                  (0100\ 1010)_2               (0100 1010)2​
   以是bytes[1]的二进制值为：0100 1010，转换成十六进制为：0x4A
  bytes发送到硬件装备，硬件装备吸收到的就是0x0E4A
3、当value大于65535时，转换为3个字节，3个字节能体现无符号的范围为0 ~                                        2                         24                                  2^{24}               224-1，即0~16777215

比方：
int value = 5623658，转换成二进制为：0101 0101 1100 1111 0110 1010
                               (                      5623658                               )                         10                                  (5623658)_{10}               (5623658)10​ →                              (                      0101                                             0101                                             1100                                             1111                                             0110                                             1010                               )                         2                                  (0101\ 0101\ 1100\ 1111\ 0110\ 1010)_2               (0101 0101 1100 1111 0110 1010)2​
转换成二进制高出16位，占用24位，占用3个字节
  1. int value =5623658
  2. byte[] bytes= new byte[3];
  3. bytes[0] =(byte) ((value >> 16) & 0xFF);
  4. bytes[1] =(byte) ((value >> 8) & 0xFF);
  5. bytes[2] =(byte) (value & 0xFF);
复制代码
bytes[0]

   (byte) ((value >> 16) & 0xFF)：>>是右移利用，(value >> 16) 是先将value的全部位向右移动16位，移动后的左边（高位）会添补0（由于是无符号右移）。
                                    (                         5623658                                   )                            10                                       (5623658)_{10}                  (5623658)10​ →                                   (                         0101                                                   0101                                                   1100                                                   1111                                                   0110                                                   1010                                   )                            2                                       (0101\ 0101\ 1100\ 1111\ 0110\ 1010)_2                  (0101 0101 1100 1111 0110 1010)2​，(5623658>> 16)得到的是                                   (                         0000                                                   0000                                                   0000                                                   0000                                                   0101                                                   0101                                   )                            2                                       (0000\ 0000\ 0000\ 0000\ 0101\ 0101)_2                  (0000 0000 0000 0000 0101 0101)2​
  & 0xFF：是按位与运算，得到末了8位，                              (                      0000                                             0000                                             0000                                             0000                                             0101                                             0101                               )                         2                                  (0000\ 0000\ 0000\ 0000\ 0101\ 0101)_2               (0000 0000 0000 0000 0101 0101)2​& 0xFF 得到的是                              (                      0101                                             0101                               )                         2                                  (0101\ 0101)_2               (0101 0101)2​
   以是bytes[0]的二进制值为：0101 0101，转换成十六进制为：0x55
  bytes[1]

   (byte) ((value >> 8) & 0xFF)：>>是右移利用，(value >> 8) 是先将value的全部位向右移动8位，移动后的左边（高位）会添补0（由于是无符号右移）。
                                    (                         5623658                                   )                            10                                       (5623658)_{10}                  (5623658)10​ →                                   (                         0101                                                   0101                                                   1100                                                   1111                                                   0110                                                   1010                                   )                            2                                       (0101\ 0101\ 1100\ 1111\ 0110\ 1010)_2                  (0101 0101 1100 1111 0110 1010)2​，(5623658>> 8)得到的是                                   (                         0000                                                   0000                                                   0101                                                   0101                                                   1100                                                   1111                                   )                            2                                       (0000\ 0000\ 0101\ 0101\ 1100\ 1111)_2                  (0000 0000 0101 0101 1100 1111)2​
  & 0xFF：是按位与运算，得到末了8位，                              (                      0000                                             0000                                             0101                                             0101                                             1100                                             1111                               )                         2                                  (0000\ 0000\ 0101\ 0101\ 1100\ 1111)_2               (0000 0000 0101 0101 1100 1111)2​ & 0xFF 得到的是                              (                      1100                                             1111                               )                         2                                  (1100\ 1111)_2               (1100 1111)2​
   以是bytes[0]的二进制值为：1100 1111，转换成十六进制为：0xCF
  bytes[2]

(byte) (value & 0xFF) ：是按位与运算，得到末了8位，                              (                      0101                                             0101                                             1100                                             1111                                             0110                                             1010                               )                         2                                  (0101\ 0101\ 1100\ 1111\ 0110\ 1010)_2               (0101 0101 1100 1111 0110 1010)2​ & 0xFF得到的是                              (                      0110                                             1010                               )                         2                                  (0110\ 1010)_2               (0110 1010)2​
   以是bytes[2]的二进制值为：0110 1010，转换成十六进制为：0x6A
  bytes发送到硬件装备，硬件装备吸收到的就是0x55CF6A
4、当value大于16777215时，转换为4个字节，4个字节能体现无符号的范围为0 ~                                        2                         32                                  2^{32}               232-1，即0~4294967295

int在java中是有符号数，int的取值范围为-                                       2                         31                                  2^{31}               231 ~                                        2                         31                                  2^{31}               231-1，即-2147483648~2147483648
比方：
int value = 316777215，转换成二进制为：0001 0010 1110 0001 1010 0010 1111 1111
                               (                      316777215                               )                         10                                  (316777215)_{10}               (316777215)10​ →                              (                      0001                                             0010                                             1110                                             0001                                             1010                                             0010                                             1111                                             1111                               )                         2                                  (0001\ 0010\ 1110\ 0001\ 1010\ 0010\ 1111\ 1111)_2               (0001 0010 1110 0001 1010 0010 1111 1111)2​
转换成二进制高出24位，占用32位，占用4个字节
  1. int value =316777215
  2. byte[] bytes= new byte[4];
  3. bytes[0] =(byte) ((value >> 24) & 0xFF);
  4. bytes[1] =(byte) ((value >> 16) & 0xFF);
  5. bytes[2] =(byte) ((value >> 8) & 0xFF);
  6. bytes[3] =(byte) (value & 0xFF);
复制代码
bytes[0]

   (byte) ((value >> 24) & 0xFF)：>>是右移利用，(value >> 24) 是先将value的全部位向右移动24位，移动后的左边（高位）会添补0（由于是无符号右移）。
                                    (                         316777215                                   )                            10                                       (316777215)_{10}                  (316777215)10​ →                                   (                         0001                                                   0010                                                   1110                                                   0001                                                   1010                                                   0010                                                   1111                                                   1111                                   )                            2                                       (0001\ 0010\ 1110\ 0001\ 1010\ 0010\ 1111\ 1111)_2                  (0001 0010 1110 0001 1010 0010 1111 1111)2​，(316777215>> 24)得到的是                                   (                         00000                                                   0000                                                   0000                                                   0000                                                   0000                                                   0000                                                   0001                                                   0010                                   )                            2                                       (00000\ 0000\ 0000\ 0000\ 0000\ 0000\ 0001\ 0010)_2                  (00000 0000 0000 0000 0000 0000 0001 0010)2​
  & 0xFF：是按位与运算，得到末了8位，                              (                      00000                                             0000                                             0000                                             0000                                             0000                                             0000                                             0001                                             0010                               )                         2                                  (00000\ 0000\ 0000\ 0000\ 0000\ 0000\ 0001\ 0010)_2               (00000 0000 0000 0000 0000 0000 0001 0010)2​ & 0xFF 得到的是                              (                      0001                                             0010                               )                         2                                  (0001\ 0010)_2               (0001 0010)2​
   以是bytes[0]的二进制值为：0001 0010，转换成十六进制为：0x12
  bytes[1]

   (byte) ((value >> 16) & 0xFF)：>>是右移利用，(value >> 16) 是先将value的全部位向右移动16位，移动后的左边（高位）会添补0（由于是无符号右移）。
                                    (                         316777215                                   )                            10                                       (316777215)_{10}                  (316777215)10​ →                                   (                         0001                                                   0010                                                   1110                                                   0001                                                   1010                                                   0010                                                   1111                                                   1111                                   )                            2                                       (0001\ 0010\ 1110\ 0001\ 1010\ 0010\ 1111\ 1111)_2                  (0001 0010 1110 0001 1010 0010 1111 1111)2​，(316777215>> 16)得到的是                                   (                         00000                                                   0000                                                   0000                                                   0000                                                   0001                                                   0010                                                   1110                                                   0001                                   )                            2                                       (00000\ 0000\ 0000\ 0000\ 0001\ 0010\ 1110\ 0001)_2                  (00000 0000 0000 0000 0001 0010 1110 0001)2​
  & 0xFF：是按位与运算，得到末了8位，                              (                      00000                                             0000                                             0000                                             0000                                             0001                                             0010                                             1110                                             0001                               )                         2                                  (00000\ 0000\ 0000\ 0000\ 0001\ 0010\ 1110\ 0001)_2               (00000 0000 0000 0000 0001 0010 1110 0001)2​ & 0xFF 得到的是                              (                      1110                                             0001                               )                         2                                  (1110\ 0001)_2               (1110 0001)2​
   以是bytes[0]的二进制值为：1110 0001，转换成十六进制为：0xE1
  bytes[2]

   (byte) ((value >> 8) & 0xFF)：>>是右移利用，(value >> 8) 是先将value的全部位向右移动8位，移动后的左边（高位）会添补0（由于是无符号右移）。
                                    (                         316777215                                   )                            10                                       (316777215)_{10}                  (316777215)10​ →                                   (                         0001                                                   0010                                                   1110                                                   0001                                                   1010                                                   0010                                                   1111                                                   1111                                   )                            2                                       (0001\ 0010\ 1110\ 0001\ 1010\ 0010\ 1111\ 1111)_2                  (0001 0010 1110 0001 1010 0010 1111 1111)2​，(316777215>> 8)得到的是                                   (                         00000                                                   0000                                                   0001                                                   0010                                                   1110                                                   0001                                                   1010                                                   0010                                   )                            2                                       (00000\ 0000\ 0001\ 0010\ 1110\ 0001\ 1010\ 0010)_2                  (00000 0000 0001 0010 1110 0001 1010 0010)2​
  & 0xFF：是按位与运算，得到末了8位，                              (                      00000                                             0000                                             0001                                             0010                                             1110                                             0001                                             1010                                             0010                               )                         2                                  (00000\ 0000\ 0001\ 0010\ 1110\ 0001\ 1010\ 0010)_2               (00000 0000 0001 0010 1110 0001 1010 0010)2​ & 0xFF 得到的是                              (                      1010                                             0010                               )                         2                                  (1010\ 0010)_2               (1010 0010)2​
   以是bytes[0]的二进制值为：1010 0010，转换成十六进制为：0xA2
  bytes[3]

(byte) (value & 0xFF) ：是按位与运算，得到末了8位，                              (                      0001                                             0010                                             1110                                             0001                                             1010                                             0010                                             1111                                             1111                               )                         2                                  (0001\ 0010\ 1110\ 0001\ 1010\ 0010\ 1111\ 1111)_2               (0001 0010 1110 0001 1010 0010 1111 1111)2​ & 0xFF得到的是                              (                      1111                                             1111                               )                         2                                  (1111\ 1111)_2               (1111 1111)2​
   以是bytes[2]的二进制值为：1111 1111，转换成十六进制为：0xFF
  bytes发送到硬件装备，硬件装备吸收到的就是0x12E1A2FF
总结：int转byte数组

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

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

比方：
  1. byte[] bytes= new byte[]{(byte) 0xF6};
复制代码
0xF6 转换成二进制为 1111 0110
  1. byte[] bytes= new byte[]{(byte) 0xF6};
  2. int value =         bytes[0]  & 0xFF;
复制代码
  (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个字节

比方：
  1. byte[] bytes= new byte[]{(byte) 0x0E,(byte) 0x4A};
复制代码
0x0E 转换成二进制为 0000 1110
0x4A 转换成二进制为 0100 1010
  1. byte[] bytes= new byte[]{(byte) 0x0E,(byte) 0x4A};
  2. int value = ((bytes[0] & 0xFF) << 8)  |  (bytes[1] & 0xFF)
复制代码
  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个字节

比方：
  1. byte[] bytes= new byte[]{(byte) 0x55,(byte) 0xCF,(byte) 0x6A};
复制代码
0x55 转换成二进制为 0101 0101
0xCF 转换成二进制为 1100 1111
0x6A 转换成二进制为 0110 1010
  1. byte[] bytes= new byte[]{(byte) 0x55,(byte) 0xCF,(byte) 0x6A};
  2. int value = ((bytes[0] & 0xFF) << 16)  | ((bytes[1] & 0xFF) << 8)  |  (bytes[2] & 0xFF)
复制代码
  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
  1. byte[] bytes= new byte[]{(byte) 0x12,(byte) 0xE1,(byte) 0xA2,(byte) 0xFF};
复制代码
0x12 转换成二进制为 0001 0010
0xE1 转换成二进制为 1110 0001
0xA2 转换成二进制为 1010 0010
0xFF 转换成二进制为 1111 1111
  1. byte[] bytes= new byte[]{(byte) 0x12,(byte) 0xE1,(byte) 0xA2,(byte) 0xFF};
  2. int value = ((bytes[0] & 0xFF) << 24)  | ((bytes[0] & 0xFF) << 16)  | ((bytes[1] & 0xFF) << 8)  |  (bytes[2] & 0xFF)
复制代码
  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数值
  1.     /**
  2.      * 将占四个字节的byte数组转换为int数值，(高位在前，低位在后的顺序)。
  3.      *
  4.      * @param src 占四个字节的byte数组
  5.      * @return int数值
  6.      */
  7.     public static int bytesToInt(byte[] src) {
  8.         int value;
  9.         value = (((src[0] & 0xFF) << 24)
  10.                 | ((src[1] & 0xFF) << 16)
  11.                 | ((src[2] & 0xFF) << 8)
  12.                 | (src[3] & 0xFF));
  13.         return value;
  14.     }
复制代码
  1.     /**
  2.      * 将字节数组的一部分转换为整数。
  3.      *
  4.      * @param bytes  字节数组
  5.      * @param start  起始位置（包含）
  6.      * @param length 要转换的字节长度
  7.      * @return 转换后的整数
  8.      */
  9.     public static int byteArrayToInt(byte[] bytes, int start, int length) {
  10.         int result = 0;
  11.         for (int i = start; i < start + length; i++) {
  12.             result = result | ((bytes[i] & 0xFF) << ((start + length - i - 1) * 8));
  13.         }
  14.         return result;
  15.     }
复制代码
三、 端序

端序：字节序
byte数据次序与内存所在高低的关系
小端（Litter Endian）：


  • 低字节在后，byte数组中序号小的在右边
大端（Big Endian）：


  • 高字节在后，byte数组中序号大的在右边
网络字节序(Network Order)：


  • TCP/IP各层协议将字节序界说为Big Endian，因此TCP/IP协议中利用的字节序通常称之为网络字节序。
主机字节序(Host Order)


  • 整数在内存中生存的次序，它通常依照Little Endian规则（不肯定，要看主机的CPU架构）。以是当两台主机之间要通过TCP/IP协议举行通讯的时间就必要调用相应的函数举行主机序列(Little Endian)和网络序(Big Endian)的转换。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
继续阅读请点击广告
回复

使用道具 举报

返回列表

祗疼妳一个
+ 我要发帖
×
登录参与点评抽奖，加入IT实名职场社区
去登录
快速回复 返回顶部 返回列表