int 和 byte数组 互相转换的方法，求高手知错？？

Question

// int 转 byte数组
public final static byte[] getBytes(int s, boolean asc)
{
    byte[] buf = new byte[4];
    if (asc)
        for (int i = buf.length - 1; i >= 0; i--) 
        {
            buf[i] = (byte) (s & 0x000000ff);
            s >>= 8;
        }
    else
        for (int i = 0; i < buf.length; i++)
        {
            buf[i] = (byte) (s & 0x000000ff);
            s >>= 8;
        }
    return buf;
}
//byte 数组转int
public final static int getInt(byte[] buf, boolean asc)
{
    if (buf == null) 
    {
        throw new IllegalArgumentException("byte array is null!");
    }
    if (buf.length > 4)
    {
        throw new IllegalArgumentException("byte array size > 4 !");
    }
    int r = 0;
    if (asc)
        for (int i = buf.length - 1; i >= 0; i--)
        {
            r <<= 8;
            r |= (buf[i] & 0x000000ff);
        }
    else
        for (int i = 0; i < buf.length; i++) 
        {
            r <<= 8;
            r |= (buf[i] & 0x000000ff);
        }
    return r;
}代码是从网上copy过来的，在执行的时候发现在相互转换的时候有问题，
 byte[] aryBtye =getBytes(10, true)
 得到的aryByte的四个元素分别为 {0,0,0,10}。
但是 执行
int value= getInt（aryBtye,true）;
value 的值并不是 10，而是一个很大的数字，
问题出在什么地方了呢？？？？

Answer 1

你这样移位就有问题 。private byte[] getHead(byte[] body) 
{
int len = body.length;
byte[] head = new byte[4];
head[0] = (byte)((len) >> 24 & 0xff);
head[1] = (byte)((len) >> 16 & 0xff);
head[2] = (byte)((len) >> 8 & 0xff);
head[3] = (byte)(len&0xff); 
return head;
}

private int getLength(byte[] in_head)
{
int len = 0;
int a = in_head.length;
len = (((in_head[0] << 24)&0xff000000) + ((in_head[1] << 16)&0xff0000) + ((in_head[2] << 8)&0xff00) + ((in_head[3]&0xff)));
return len;
}
 

Answer 2

好像反了，一个true，一个false试试。
byte[] aryBtye =getBytes(10, true);
int value= getInt(aryBtye,false);

Answer 3

你把升序和降序搞反了吧 
如果getBytes(10, true);这个是按升序  即  10,0,0,0
如果getBytes(10, false);这个是按降序 即 0,0,0,10

Answer 4

byte类型 操作时其实会变成int，使用移位时,假设定义byte b;
b >>= 10; 其实是转换成int在转换成byte进行赋值，高位被填充了。同理，char、short也是如此。

Answer 5

public static byte[] intToByteArray(int i) throws Exception {
ByteArrayOutputStream buf = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(buf);
dos.writeInt(i);
byte[] b = buf.toByteArray();
dos.close();
buf.close();
return b;
}

Answer 6

建议楼主要用高级语言就不要出现s & 0x000000ff

Answer 7

    public static byte[] int2BytesBE(int num) {
        byte[] bys = new byte[Integer.SIZE / Byte.SIZE];
        for(int i = 0, k = bys.length; i < k; i++) {
            bys[i] = (byte)(num >>> ((k - 1 - i) * Byte.SIZE) & 0xff);
        }
        return bys;
    }
    
    public static byte[] int2BytesLE(int num) {
        return int2BytesBE(Integer.reverseBytes(num));
    }
    
    /**
     * 采用 Big-Endian 方式将 long 数据转为 byte 数组
     * 
     * @param num
     * @return  转为 Big-Endian 方式的 byte 数组 
     */
    public static byte[] long2BytesBE(long num) {
        byte[] bys = new byte[Long.SIZE / Byte.SIZE];
        for(int i = 0, k = bys.length; i < k; i++) {
            bys[i] = (byte)(num >>> ((k - 1 - i) * Byte.SIZE) & 0xff);
        }
        return bys;
    }
    
    /**
     * 采用 Little-Endian 方式将 long 数据转为 byte 数组
     * 
     * @param num
     * @return  转为 Little-Endian 方式的 byte 数组 
     */
    public static byte[] long2BytesLE(long num) {        
        return long2BytesBE(Long.reverseBytes(num));
    }
    
    /**
     * 将 Little-Endian 的字节数组转为 int 类型的数据<br />
     * Little-Endian 表示高位字节在低位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 LE 方式表示的 int 数值
     */
    public static int bytes2IntLE(byte[] bys, int start, int len) {
        return bytes2Int(bys, start, len, false);
    }
    
    /**
     * 将 Big-Endian 的字节数组转为 int 类型的数据<br />
     * Big-Endian 表示高位字节在高位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 BE 方式表示的 int 数值
     */
    public static int bytes2IntBE(byte[] bys, int start, int len) {
        return bytes2Int(bys, start, len, true);
    }
    
    private static int bytes2Int(byte[] bys, int start, int len, 
            boolean isBigEndian) {
        int n = 0;
        for(int i = start, k = start + len % (Integer.SIZE / Byte.SIZE + 1); i < k; i++) {
            n |= (bys[i] & 0xff) << ((isBigEndian ? (k - i - 1) : i) * Byte.SIZE);
        }
        return n;
    }
    
    /**
     * 将 Little-Endian 的字节数组转为 long 类型的数据<br />
     * Little-Endian 表示高位字节在低位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 LE 方式表示的 long 数值
     */
    public static long bytes2LongLE(byte[] bys, int start, int len) {
        return bytes2Long(bys, start, len, false);
    }
    
    public static long bytes2LongLE(byte[] bys) {
        return bytes2Long(bys, 0, bys.length, false);
    }
    
    /**
     * 将 Big-Endian 的字节数组转为 long 类型的数据<br />
     * Big-Endian 表示高位字节在高位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 BE 方式表示的 long 数值
     */
    public static long bytes2LongBE(byte[] bys, int start, int len) {
        return bytes2Long(bys, start, len, true);
    }
    
    public static long bytes2LongBE(byte[] bys) {
        return bytes2Long(bys, 0, bys.length, true);
    }
    
    private static long bytes2Long(byte[] bys, int start, int len, 
            boolean isBigEndian) {
        long n = 0L;
        for(int i = start, k = start + len % (Long.SIZE / Byte.SIZE + 1); i < k; i++) {
            n |= (bys[i] & 0xffL) << ((isBigEndian ? (k - i - 1) : i) * Byte.SIZE);
        }
        return n;
    }

Answer 8

關鍵你要自己知道原理，瞭解了int和byte[]之間爲什麽轉換和如何轉換就ok了
int是32bit,byte是8bit
int的字面值可以由4個byte組成，但各個byte的權值不同假如某個int值是abcd（a,b,c,d各為一個byte字面值）則abcd的10進制值為：
abcd=a*256(3) + b*256(2) + c*256(1) + d*256(0)這裡其實相當於256進制了，這是在一個相對較高的權值粒度上去觀察的結果用二進制看int，以下每一個字母代表一個二進制位，各二進制位權值各不相同
aaaaaaaa bbbbbbbb cccccccc dddddddd

Answer 9

以前也用for循环来着，后来发现，int一共才4字节，直接舍弃for循环，编码搞定。思路也清晰。
long型数据，不也才8字节嘛，与其编写for循环，判断每个循环的逻辑功能，不如直接编码。