java中大小端问题研究

关于大小端在内存中的存储

最近在学习读取音频格式文件的时候碰到一个问题,因为音频文件中有四个字节的int型是以little-endian形式存储的,需要转换为java中的big-endian模式。int转byte[]相对简单,只需要做位移缩窄就行了,但是byte[]转int的时候涉及到负数的问题,负数在计算机内中是以补码的形式存在的,容易出现一些问题。

数据是以二进制(0,1)的形式存储在计算机中,每一个这样的数据被称为bit,bit只能是0或者1,将8个bit位定义为一个byte,这样一个byte就能表示2^8个数据。java中1个字节就是1byte,short类型占2byte,int类型占4byte,long类型占8byte,float类型占8byte,double类型占16byte。

下面主要讲一下byte和int之间的转换。

java中没有unsinged类型,也就是byte只能是有符号类型,为了表示正负号,一般使用最高位来表示正负。比如byte i=6,转为二进制码为0000 0110,,在内存中存储如下:

1
2
3
4
5
6
+------------------------------+
| 0 | 0 | 0 | 0 | 0 | 1 | 1| 0 |
+------------------------------+
  ^
  |
符号位

负数的存储相对比较麻烦,是以补码的形式存储的,补码就是对原有的正数所有的位取反码然后加1; 比如byte i=-6,则相当于对6取反码然后加1;

1
2
3
0000 0110 取反码为 1111 1001

1111 1001 加1为    11111010

则可以得到最后的结果为11111010,在内存中存储如下:

1
2
3
4
5
6
+------------------------------+
| 1 | 1 | 1 | 1 | 1 | 0 | 1| 0 |
+------------------------------+
  ^
  |
符号位

此处可以有一个简单的验证方法,即原码+补码会越位进1。

1
2
3
4
    0000 0110
+   1111 1010
--------------
= 1 0000 0000

在内存中存储是以byte为单位的,在byte拼接的过程中就演化除了两种形式:little-endian`,big-endianlittle-endian适用于机器读懂的顺序,它是前边的地址存储低位的byte,后边的地址存储在高位的地址。 安卓的jni中全部采用little-ednain,int i=6,转换为2进制表示为0000 0110 0000 0000 0000 0000 0000 0000` 在内存中的表示:

1
2
3
4
5
6
+-----------------+---------------+---------------+---------------+
|0|0|0|0|0|1|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0| 0 |0|0|0|0|0|0|
+-----------------+---------------+---------------+---------------+
                                                    ^
                                                    |
                                                  符号位

big-endian适用于人类读的顺序,前边的地址存储高位的byte,后边的地址存储低位的地址。 java中int类型的存储方式是big-endian`,int i=6,转换为2进制表示为0000 0000 0000 0000 0000 0000 0000 0110`, 在内存中的表示:

1
2
3
4
5
6
+-----------------+---------------+---------------+---------------+
| 0 |0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|1|0|
+-----------------+---------------+---------------+---------------+
  ^
  |
符号位

同样对于int i=-6的计算也类似于byte的计算,先取反码再加1,然后排序:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
big-endian:
+-----------------+---------------+---------------+---------------+
| 1 |1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|0|1|0|
+-----------------+---------------+---------------+---------------+
  ^
  |
符号位

little-endian:
+-----------------+---------------+---------------+---------------+
|1|1|1|1|1|0|0|1|0|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1| 1 |1|1|1|1|1|1|
+-----------------+---------------+---------------+---------------+
                                                    ^
                                                    |
                                                  符号位

利用位运算来进行大小端转换

接下来讲一下如何在byte[]和int之间转换

1
2
int num=1505;
byte[] result=new byte[4];

这样的一个整数,在java内存以二进制形式表示为:

1
2
3
+-----------------+---------------+---------------+---------------+
|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|0|1|1|1|1|0|0|0|0|1|
+-----------------+---------------+---------------+---------------+
1
2
3
4
byte[0]=00000000=0;
byte[1]=00000000=0;
byte[2]=00000101=5;
byte[3]=11100001=-31;

这里只说一下最后一个字节是如何算出来的,11100001是一个负数,负数是原码取反加1,想获得源码需要先减1,得到11100000,再取反码得到00011111,计算可得是31,由于是负数所以取-31。

这样就完成了int到byte[]的转换。

想要byte[]转int只需将数组拼接起来即可。在操作的过程中要注意一点,byte执行位运算会自动转换为int型,并且补前边的位的时候是自动补上的符号位。 比如前边的result转换为int后如下:

1
2
3
4
byte[0]=00000000 00000000 00000000 00000000;
byte[1]=00000000 00000000 00000000 00000000;
byte[2]=00000000 00000000 00000000 00000101;
byte[3]=11111111 11111111 11111111 11100001;

这个时候我们就需要使用最常见的&0xff来处理前边的符号位了。

首先写一个简单的程序来将int转换为big-endian的byte:

1
2
3
4
5
6
7
private static byte[] intToByteBig(int i) {
        byte[] result = new byte[4];
        result[0] = (byte) (i >> 24 & 0xff);
        result[1] = (byte) (i >> 16 & 0xff);
        result[2] = (byte) (i >> 8 & 0xff);
        result[3] = (byte) (i >> 0 & 0xff);
        return result;

假如要转换成little-endian,只需要调整字节排放顺序:

1
2
3
4
5
6
7
private static byte[] intToByteLittle(int i) {
        byte[] result = new byte[4];
        result[3] = (byte) (i >> 24 & 0xff);
        result[2] = (byte) (i >> 16 & 0xff);
        result[1] = (byte) (i >> 8 & 0xff);
        result[0] = (byte) (i >> 0 & 0xff);
        return result;

同理我们可以得出一个方法来让byte转int:

1
2
3
4
5
6
7
private static int bigByteToInt(byte[] b) {
        int one = ((int) b[0] & 0xff) << 24;
        int two = ((int) b[1] & 0xff) << 16;
        int three = ((int) b[2] & 0xff) << 8;
        int four = ((int) b[3] & 0xff) << 0;
        return one + two + three + four;
    }
1
2
3
4
5
6
7
private static int littleByteToInt(byte[] b) {
        int one = ((int) b[3] & 0xff) << 24;
        int two = ((int) b[2] & 0xff) << 16;
        int three = ((int) b[1] & 0xff) << 8;
        int four = ((int) b[0] & 0xff) << 0;
        return one + two + three + four;
    }

关于这个工具类我上传到了我的github,有需要的朋友可以直接复制粘贴。

github地址–ByteUtil

关于ByteBuffer的使用

其实上边的内容理解了原理就可以了,在java中已经有封装好的类来实现真正的big-endian和little-endian的转换。 ByteBuffer中有一个方法是order(),这个方法接收一个参数,这个参数就可以来进行大小端转换:

  • BIG-ENDIAN 在ByteBuffer中以big-endian形式存储
  • LITTLE-ENDIAN 在ByteBuffer中以little-endian形式存储

看一段示例代码

1
2
3
4
5
6
public static short littleByteToShort(byte[] data) {
    if (data.length != 2) {
        throw new UnsupportedOperationException("the byte length is not 2");
    }
    return ByteBuffer.allocate(data.length).order(ByteOrder.LITTLE_ENDIAN).put(data).getShort(0);
}

这个方法是little-endian转换为short。ByteBuffer.allocate(data.length)分配了2个字节的byteffuer,order(ByteOrder.LITTLE_ENDIAN),让bytebuffer以小端形式存储,put(data)将字节数组存入bytebuffer中,getShort(0)将bytebuffer读取为short类型,注意参数0必须传入,因为put()方法将指针移动了两个字节,所以传入0是从index为0的地方读取一个short。否则会报越界问题。 关于int和long类型的转换依然如此,如果是big-endian,则order()方法需传入参数BIG-ENDIAN。

1
2
3
public static byte[] shortToLittleByte(short data) {
    return ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort(data).array();
}

这个比较简单,类似于byte[]转short,只是putshort后要调用array来转换为byte[]。

最后也附上这个简单的方法地址,欢迎赋值粘贴:(测试已通过)

github地址–ByteBufferUtil