大小端问题由来已久，和计算机的处理器有关。简单来说，大端模式，是指数据的高位，保存在内存的低地址中，而数据的低位，保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；小端模式，是指数据的高位保存在内存的高地址中，而数 据的低位保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致。一般来说，这有些像吃甘庶，有些ＣＰＵ喜欢从根部吃起，有些喜欢从顶部吃起，这原本不存在问题，让你吃个char，有人从底部吃一节，有人从顶部吃一节，让吃个short，有人从底部吃两节，有人从顶部吃两节。不过如果不同处理器的电脑用于数据交换，就会带来问题，你很可能会嫌弃他换给你的甘庶不和你的口味，这时就要加工。这就是大小端转换。网络传输使用的是字节码，单个byte组成的数组，要把二个字节的short或者四个字节int的内容，转换成按大端或者小端排列的byte数组，转换成适合对方口味的顺序，就容易完成交换了。这就是大小端的来历，一般来说，大羰的机器转成的字节码和小端的机器转成的字节码正好相反，反序排列一下，就可以实现互相通信。所以大小端的转换比较简单。函数如下：为了方便，int的len为4，short为2，byte为１，一个函数对应大端，一个函数对应小端。        

public static byte[] little_intToByte(int i, int len) {  
        byte[] abyte = new byte[len];  
        if (len == 1) {  
            abyte[0] = (byte) (0xff & i);  
        } else if (len == 2) {  
            abyte[0] = (byte) (0xff & i);  
            abyte[1] = (byte) ((0xff00 & i) >> 8);  
        } else {  
            abyte[0] = (byte) (0xff & i);  
            abyte[1] = (byte) ((0xff00 & i) >> 8);  
            abyte[2] = (byte) ((0xff0000 & i) >> 16);  
            abyte[3] = (byte) ((0xff000000 & i) >> 24);  
        }  
        return abyte;  
    }  
  
    public static int little_bytesToInt(byte[] bytes) {  
        int addr = 0;  
        if (bytes.length == 1) {  
            addr = bytes[0] & 0xFF;  
        } else if (bytes.length == 2) {  
            addr = bytes[0] & 0xFF;  
            addr |= (((int) bytes[1] << 8) & 0xFF00);  
        } else {  
            addr = bytes[0] & 0xFF;  
            addr |= (((int) bytes[1] << 8) & 0xFF00);  
            addr |= (((int) bytes[2] << 16) & 0xFF0000);  
            addr |= (((int) bytes[3] << 24) & 0xFF000000);  
        }  
        return addr;  
    }  
  
    /** 
     * int to byte[] 支持 1或者 4 个字节 
     *  
     * @param i 
     * @param len 
     * @return 
     */  
    public static byte[] big_intToByte(int i, int len) {  
        byte[] abyte = new byte[len];  
        ;  
        if (len == 1) {  
            abyte[0] = (byte) (0xff & i);  
        } else if (len == 2) {  
            abyte[0] = (byte) ((i >>> 8) & 0xff);  
            abyte[1] = (byte) (i & 0xff);  
        } else {  
            abyte[0] = (byte) ((i >>> 24) & 0xff);  
            abyte[1] = (byte) ((i >>> 16) & 0xff);  
            abyte[2] = (byte) ((i >>> 8) & 0xff);  
            abyte[3] = (byte) (i & 0xff);  
        }  
        return abyte;  
    }  
  
    public static int big_bytesToInt(byte[] bytes) {  
        int addr = 0;  
        if (bytes.length == 1) {  
            addr = bytes[0] & 0xFF;  
        } else if (bytes.length == 2) {  
            addr = bytes[0] & 0xFF;  
            addr = (addr << 8) | (bytes[1] & 0xff);  
        } else {  
            addr = bytes[0] & 0xFF;  
            addr = (addr << 8) | (bytes[1] & 0xff);  
            addr = (addr << 8) | (bytes[2] & 0xff);  
            addr = (addr << 8) | (bytes[3] & 0xff);  
        }  
        return addr;  
    }  

 

  这个是看大小端的函数：  

// 获得本机ＣＰＵ大小端  
    public static boolean isBigendian() {  
        short i = 0x1;  
        boolean bRet = ((i >> 8) == 0x1);  
        Log.i(tags, "bRet = " + bRet);  
        return bRet;  
    }