byte 数组和 short、int 之间转换「转」

在项目中很多时候我们会遇到 byte[]int 之间的相互转换问题,使用 ByteBuffer 可以很优雅的解决这个问题。

可以设置大端模式 ByteOrder.BIG_ENDIAN 和小端模式 ByteOrder LITTLE_ENDIAN:

例如数据为十六进制: 00 00 0x01 0x32 转换为 byte[] 数组为 byte[0] = 0, byte[1] = 0, byte[2] = 1, byte[3] = 50

这种情况下可以使用大端模式转换,如果是十六进制:0x32 0x01 00 00 则可以使用小端模式转换。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/**
 * 将int数值转换为占四个字节的byte数组
 *
 * @param intVal    int 要转换的int值
 * @param byteOrder ByteOrder 大小端模式
 * @return byte[]
 */
public static byte[] int2bytes(int intVal, ByteOrder byteOrder) {
    ByteBuffer buffer = ByteBuffer.allocate(4);
    buffer.order(byteOrder);
    buffer.asIntBuffer().put(intVal);
    return buffer.array();
}

/**
 * 取四个字节的byte数组所代表的int值
 *
 * @param bytes     byte[]
 * @param byteOrder ByteOrder 大小端模式
 * @return int
 */
private static int bytes2int(byte[] bytes, ByteOrder byteOrder) {
    ByteBuffer buffer = ByteBuffer.wrap(bytes);
    buffer.order(byteOrder);
    return buffer.getInt();
}

/**
 * 将short数值转换为占两个字节的Byte数组
 *
 * @param shortVal  short 要转换的short值
 * @param byteOrder ByteOrder 大小端模式
 * @return Byte[]
 */
public static Byte[] short2Bytes(short shortVal, ByteOrder byteOrder) {
    ByteBuffer buffer = ByteBuffer.allocate(2);
    buffer.order(byteOrder);
    buffer.asShortBuffer().put(shortVal);
    byte[] array = buffer.array();
    return bytes2Bytes(array);
}

/**
 * 将short数值转换为占两个字节的byte数组
 *
 * @param shortVal  short 要转换的short值
 * @param byteOrder ByteOrder 大小端模式
 * @return byte[]
 */
public static byte[] short2bytes(short shortVal, ByteOrder byteOrder) {
    ByteBuffer buffer = ByteBuffer.allocate(2);
    buffer.order(byteOrder);
    buffer.asShortBuffer().put(shortVal);
    return buffer.array();
}

/**
 * 取两个字节的byte数组所代表的short值
 *
 * @param bytes     byte[]
 * @param byteOrder ByteOrder 大小端模式
 * @return short
 */
public static short bytes2short(byte[] bytes, ByteOrder byteOrder) {
    ByteBuffer buffer = ByteBuffer.wrap(bytes);
    buffer.order(byteOrder);
    return buffer.getShort();
}

/**
 * 将byte[]转为Byte[]
 *
 * @param array byte[]
 * @return Byte[]
 */
public static Byte[] bytes2Bytes(byte[] array) {
    if (null == array) {
        return null;
    }
    Byte[] bytes = new Byte[array.length];
    for (int i = 0; i < array.length; i++) {
        bytes[i] = array[i];
    }
    return bytes;
}

当然,也可以使用 位运算 实现,但是我更加推荐上面的 ByteBuffer 方式。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 /*** 将short数值转换为占两个字节的byte数组,本方法适用于(低位在前,高位在后)的顺序。
 * <p>与bytesToShort_LH配套使用</p>
 *
 * @param shortVal short 要转换的short值
 * @return byte[] Byte数组
 */
  public static byte[] shortToBytes_LH(short shortVal) {
    byte[] bytes = new byte[2];
    bytes[0] = (byte) (shortVal & 0xff);
    bytes[1] = (byte) (shortVal >> 8 & 0xff);
    return bytes;
}

/*** 将short数值转换为占两个字节的Byte数组,本方法适用于(低位在前,高位在后)的顺序。
 * <p>与bytesToShort_LH配套使用</p>
 *
 * @param shortVal short 要转换的short值
 * @return Byte[] byte数组
 */
public static Byte[] short2Bytes_LH(short shortVal) {
    Byte[] bytes = new Byte[2];
    bytes[0] = (byte) (shortVal & 0xff);
    bytes[1] = (byte) (shortVal >> 8 & 0xff);
    return bytes;
}

/*** 将short数值转换为占两个字节的byte数组,本方法适用于(低位在前,高位在后)的顺序。
 * <p>与bytesToInt_HL配套使用</p>
 *
 * @param shortVal int 要转换的int值
 * @return byte[] byte数组
 */
public static byte[] shortToBytes_HL(short shortVal) {
    byte[] bytes = new byte[2];
    bytes[0] = (byte) (shortVal >> 8 & 0xff);
    bytes[1] = (byte) (shortVal & 0xff);
    return bytes;
}

/**
 * byte数组中取short数值,本方法适用于(低位在前,高位在后)的顺序。
 * <p>与shortToBytes_LH配套使用</p>
 *
 * @param src    byte[]  byte数组
 * @param offset int 从数组的第offset位开始
 * @return int 数值
 */
public static short bytesToShort_LH(byte[] src, int offset) {
    short value;
    value = (short) (src[offset] & 0x00ff | ((src[offset + 1]) << 8) & 0xff00);
    return value;
}

/**
 * byte数组中取short数值,本方法适用于(低位在后,高位在前)的顺序。
 * <p>与shortToBytes_HL配套使用</p>
 *
 * @param src    byte[]  byte数组
 * @param offset int 从数组的第offset位开始
 * @return int 数值
 */
public static short bytesToShort_HL(byte[] src, int offset) {
    short value;
    value = (short) (((src[offset]) << 8) & 0xff00 | src[offset + 1] & 0x00ff);
    return value;
}

 /////////////////////////////  int   /////////////////////////////

/*** 将int数值转换为占四个字节的byte数组,本方法适用于(低位在前,高位在后)的顺序。
 * <p>与bytesToInt_LH配套使用</p>
 *
 * @param intVal int 要转换的int值
 * @return byte[] byte数组
 */
public static byte[] intToBytes_LH(int intVal) {
    byte[] bytes = new byte[4];
    bytes[0] = (byte) (intVal & 0xff);
    bytes[1] = (byte) (intVal >> 8 & 0xff);
    bytes[2] = (byte) (intVal >> 16 & 0xff);
    bytes[3] = (byte) (intVal >> 24 & 0xff);
    return bytes;
}

/*** 将int数值转换为占四个字节的Byte数组,本方法适用于(低位在前,高位在后)的顺序。
 * <p>与bytesToInt_LH配套使用</p>
 *
 * @param intVal int 要转换的int值
 * @return Byte[] Byte数组
 */
public static Byte[] int2Bytes_LH(int intVal) {
    Byte[] bytes = new Byte[4];
    bytes[0] = (byte) (intVal & 0xff);
    bytes[1] = (byte) (intVal >> 8 & 0xff);
    bytes[2] = (byte) (intVal >> 16 & 0xff);
    bytes[3] = (byte) (intVal >> 24 & 0xff);
    return bytes;
}

/*** 将int数值转换为占四个字节的byte数组,本方法适用于(高位在前,低位在后)的顺序。
 * <p>与bytesToInt_HL配套使用</p>
 *
 * @param intVal int  要转换的int值
 * @return byte[] byte数组
 */
public static byte[] intToBytes_HL(int intVal) {
    byte[] bytes = new byte[4];
    bytes[0] = (byte) ((intVal >> 24) & 0xFF);
    bytes[1] = (byte) ((intVal >> 16) & 0xFF);
    bytes[2] = (byte) ((intVal >> 8) & 0xFF);
    bytes[3] = (byte) (intVal & 0xFF);
    return bytes;
}

/**
 * byte数组中取int数值,本方法适用于(低位在前,高位在后)的顺序。
 * <p>与intToBytes_LH配套使用</p>
 *
 * @param src    byte[]  byte数组
 * @param offset int 从数组的第offset位开始
 * @return int 数值
 */
public static int bytesToInt_LH(byte[] src, int offset) {
    int value;
    value = (((src[3 + offset] & 0x00ff) << 24) & 0xff000000)
            | (((src[2 + offset] & 0x00ff) << 16) & 0x00ff0000)
            | (((src[1 + offset] & 0x00ff) << 8) & 0x0000ff00)
            | ((src[offset] & 0x00ff));
    return value;
}

/**
 * byte数组中取int数值,本方法适用于(低位在后,高位在前)的顺序。
 * <p>与intToBytes_Hl配套使用</p>
 *
 * @param src    byte[]  byte数组
 * @param offset int 从数组的第offset位开始
 * @return int 数值
 */
public static int bytesToInt_HL(byte[] src, int offset) {
    int value;
    value = (((src[offset] & 0xFF) << 24)
            | ((src[offset + 1] & 0xFF) << 16)
            | ((src[offset + 2] & 0xFF) << 8)
            | (src[offset + 3] & 0xFF));
    return value;
}

本文转载自:https://www.jianshu.com/p/c1b5bb2346bc 和 https://www.jianshu.com/p/fafa9b8b7379