int 转换成 byte ，是不是除以256？

Question

比如Integer a=270；
我要转换成 byte，放在一个 byte的2维数组里，[][] 前面是高位，后面是低位。
这应该怎么转换？
我是 a/256 商放在前面。
a%256余数放在后面.这样可以？

Answer 1

integer有个byteValue() ;返回byte

Answer 2

integer.byteValue() 
可以直接转换成Byte   

Answer 3

这个方法只会返回int的低8位数据，不能返回int的全部数据的

Answer 4

一个int放在4个byte里
value%256
value/256%256
value/65536%256
value/16777216%256
或
value&255
(value>>8)&255
(value>>16)&255
(value>>24)&255

Answer 5

获得Int 4个字节分别代表的数值
     int num=257;
    byte[] data=new byte[4];
    data[3]=(byte)num;
    data[2]=(byte) (num>>8 | 0);
    data[1]=(byte) (num>>16 | 0);
    data[0]=(byte) (num>>24 | 0);
    
为了证明Java是高字节开头的，下面这段程序s的值为257，是正确的。
     ByteArrayInputStream bais=new ByteArrayInputStream(data);
    DataInputStream dis=new DataInputStream(bais);
    int s=dis.readInt();

Answer 6

实际上 就是 a=270，转换成byte数组就是 b[1][14]?

Answer 7

我知道了。
byte占256长度，超过则溢出，进一位。

Answer 8

int 数值大于256就会把多余的高位给丢掉了

Answer 9

int 类型是4字节的放在byte数组里,要一个长度至少为4的byte数组
怎么放涉及到尾序的问题,具体看你的需求了...我之前写过一个工具体,就是把long int short byte 放到byte[]里的,代码贴给你吧
import java.nio.ByteOrder;public class BitConverters {    //ByteOrder nativeOrder = ByteOrder.nativeOrder();
    /**
     *
     * @param var
     * @return
     */
    public static byte changeEndian(byte var) {
        return var;
    }    public static int changeEndian(int var) {
        int tmp = 0;
        tmp += (var & 0xFF) << 24;
        tmp += (var & 0xFF00) << 8;
        tmp += (var & 0x00FF0000) >> 8;
        tmp += var >>> 24;
        return tmp;
    }    public static short changeEndian(short var) {
        int tmp = 0;
        tmp += (var >> 8) & 0xFF;
        tmp += (var & 0xFF) << 8;
        return (short) tmp;
    }    public static long changeEndian(long var) {
        long tmp = 0L;
        tmp += (var & 0xFFL) << 56;
        tmp += (var & 0xFF00L) << 40;
        tmp += (var & 0xFF0000L) << 24;
        tmp += (var & 0xFF000000L) << 8;
        tmp += (var & 0xFF00000000L) >> 8;
        tmp += (var & 0xFF0000000000L) >> 24;
        tmp += (var & 0xFF000000000000L) >> 40;
        tmp += var >>> 56;        return tmp;
    }    public static byte getByte(byte[] buffer, int startIndex) throws IllegalArgumentException, IndexOutOfBoundsException {
        if (startIndex < 0) {
            throw new IllegalArgumentException();
        }
        if (buffer.length > startIndex) {
            return buffer[startIndex];
        }
        throw new IndexOutOfBoundsException();
    }    public static byte getByte(byte[] buffer, int startIndex, ByteOrder order) throws IllegalArgumentException, IndexOutOfBoundsException {
        return (getByte(buffer, startIndex));
    }    public static short getShort(byte[] buffer, int startIndex, ByteOrder order) throws IllegalArgumentException, IndexOutOfBoundsException {
        if (startIndex < 0) {
            throw new IllegalArgumentException();
        }
        if (buffer.length > startIndex + 1) {
            int tmp = 0;
            if (order == ByteOrder.BIG_ENDIAN) {
                tmp += buffer[startIndex] << 8;
                tmp += buffer[startIndex + 1] & 0xFF;            } else {
                tmp += buffer[startIndex + 1] << 8;
                tmp += buffer[startIndex] & 0xFF;
            }
            return (short) tmp;
        }
        throw new IndexOutOfBoundsException();
    }    public static int getInt(byte[] buffer, int startIndex, ByteOrder order) throws IllegalArgumentException, IndexOutOfBoundsException {
        if (startIndex < 0) {
            throw new IllegalArgumentException();
        }
        if (buffer.length > startIndex + 3) {
            int tmp = 0;
            if (order == ByteOrder.BIG_ENDIAN) {
                tmp += buffer[startIndex] << 24;
                tmp += (buffer[startIndex + 1] & 0xFF) << 16;
                tmp += (buffer[startIndex + 2] & 0xFF) << 8;
                tmp += (buffer[startIndex + 3] & 0xFF);            } else {
                tmp += buffer[startIndex] & 0xFF;
                tmp += (buffer[startIndex + 1] & 0xFF) << 8;
                tmp += (buffer[startIndex + 2] & 0xFF) << 16;
                tmp += (buffer[startIndex + 3]) << 24;
            }
            return tmp;
        }
        throw new IndexOutOfBoundsException();
    }    public static long getLong(byte[] buffer, int startIndex, ByteOrder order) throws IllegalArgumentException, IndexOutOfBoundsException {
        if (startIndex < 0) {
            throw new IllegalArgumentException();
        }
        if (buffer.length > startIndex + 7) {
            long tmp = 0;
            if (order == ByteOrder.BIG_ENDIAN) {
                tmp += (long) buffer[startIndex] << 56;
                tmp += (buffer[startIndex + 1] & 0xFFL) << 48;
                tmp += (buffer[startIndex + 2] & 0xFFL) << 40;
                tmp += (buffer[startIndex + 3] & 0xFFL) << 32;
                tmp += (buffer[startIndex + 4] & 0xFFL) << 24;
                tmp += (buffer[startIndex + 5] & 0xFFL) << 16;
                tmp += (buffer[startIndex + 6] & 0xFFL) << 8;
                tmp += (buffer[startIndex + 7] & 0xFFL);            } else {
                tmp += buffer[startIndex] & 0xFF;
                tmp += (buffer[startIndex + 1] & 0xFFL) << 8;
                tmp += (buffer[startIndex + 2] & 0xFFL) << 16;
                tmp += (buffer[startIndex + 3] & 0xFFL) << 24;
                tmp += (buffer[startIndex + 4] & 0xFFL) << 32;
                tmp += (buffer[startIndex + 5] & 0xFFL) << 40;
                tmp += (buffer[startIndex + 6] & 0xFFL) << 48;
                tmp += ((long) buffer[startIndex + 7]) << 56;            }
            return tmp;
        }
        throw new IndexOutOfBoundsException();
    }    public static byte[] getBytes(short var, ByteOrder order) {
        byte[] tmp = new byte[2];
        if (order == ByteOrder.BIG_ENDIAN) {
            tmp[0] = (byte) (var >>> 8);
            tmp[1] = (byte) (var);
        } else {
            tmp[0] = (byte) (var);
            tmp[1] = (byte) (var >>> 8);        }
        return tmp;
    }    public static byte[] getBytes(int var, ByteOrder order) {
        byte[] tmp = new byte[4];
        if (order == ByteOrder.BIG_ENDIAN) {
            tmp[0] = (byte) (var >>> 24);
            tmp[1] = (byte) (var >>> 16);
            tmp[2] = (byte) (var >>> 8);
            tmp[3] = (byte) var;
        } else {
            tmp[0] = (byte) var;
            tmp[1] = (byte) (var >>> 8);
            tmp[2] = (byte) (var >>> 16);
            tmp[3] = (byte) (var >>> 24);        }
        return tmp;
    }    public static byte[] getBytes(long var, ByteOrder order) {
        byte[] tmp = new byte[8];        if (order == ByteOrder.BIG_ENDIAN) {
            tmp[7] = (byte) var;
            tmp[6] = (byte) (var >>> 8);
            tmp[5] = (byte) (var >>> 16);
            tmp[4] = (byte) (var >>> 24);
            tmp[3] = (byte) (var >>> 32);
            tmp[2] = (byte) (var >>> 40);
            tmp[1] = (byte) (var >>> 48);
            tmp[0] = (byte) (var >>> 56);
        } else {
            tmp[0] = (byte) var;
            tmp[1] = (byte) (var >>> 8);
            tmp[2] = (byte) (var >>> 16);
            tmp[3] = (byte) (var >>> 24);
            tmp[4] = (byte) (var >>> 32);
            tmp[5] = (byte) (var >>> 40);
            tmp[6] = (byte) (var >>> 48);
            tmp[7] = (byte) (var >>> 56);
        }
        return tmp;
    }
}