Java整数到字节数组

我得到一个整数：

1695609641

当我使用这个方法时：

String hex = Integer.toHexString(1695609641);
system.out.println(hex); 

给出：

6510f329

但我想要一个字节数组：

byte[] bytearray = new byte[] { (byte) 0x65, (byte)0x10, (byte)0xf3, (byte)0x29};

public byte[] intToBytes(int my_int) throws IOException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutput out = new ObjectOutputStream(bos);
    out.writeInt(my_int);
    out.close();
    byte[] int_bytes = bos.toByteArray();
    bos.close();
    return int_bytes;
}

我怎么做这个

integer & 0xFF

第一个字节

(integer >> 8) & 0xFF

对于第二个and循环等，写入预分配的字节数组。不幸的是，有点乱。

那么：

public static final byte[] intToByteArray(int value) {
    return new byte[] {
            (byte)(value >>> 24),
            (byte)(value >>> 16),
            (byte)(value >>> 8),
            (byte)value};
}

这个主意不是我的。我从中获得了它。

使用Java NIO非常简单：

byte[] bytes = ByteBuffer.allocate(4).putInt(1695609641).array();

for (byte b : bytes) {
   System.out.format("0x%x ", b);
}

输出：

0x65 0x10 0xf3 0x29 0x65 0x10 0xf3 0x29

---

biginger.valueOf（1695609641）.toByteArray（）

类org.apache.hadoop.hbase.util.Bytes有一系列方便的byte[]转换方法，但您可能不希望仅出于此目的将整个hbase jar添加到项目中。令人惊讶的是，这种方法不仅在JDK中缺少AFAIK，而且在commons io等明显的LIB中也缺少AFAIK。

下面的块至少用于通过UDP发送int

int到字节数组：

byte[] bytearray = new byte[] { (byte) 0x65, (byte)0x10, (byte)0xf3, (byte)0x29};

public byte[] intToBytes(int my_int) throws IOException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutput out = new ObjectOutputStream(bos);
    out.writeInt(my_int);
    out.close();
    byte[] int_bytes = bos.toByteArray();
    bos.close();
    return int_bytes;
}

字节数组到int：

public int bytesToInt(byte[] int_bytes) throws IOException {
    ByteArrayInputStream bis = new ByteArrayInputStream(int_bytes);
    ObjectInputStream ois = new ObjectInputStream(bis);
    int my_int = ois.readInt();
    ois.close();
    return my_int;
}

我的尝试：

使用它，您可以执行以下操作：

byte[] fourBytes = toBytes(0x01020304);
byte[] eightBytes = toBytes(0x01020304, 0x05060708);

完整类在这里：，它支持从短或长初始化

byte[] eightBytesAgain = toBytes(0x0102030405060708L);

使用：

---

由于通常您希望在以后将此数组转换回int，因此以下是将int数组转换为字节数组的方法，反之亦然：

public static byte[] convertToByteArray(final int[] pIntArray)
{
    final byte[] array = new byte[pIntArray.length * 4];
    for (int j = 0; j < pIntArray.length; j++)
    {
        final int c = pIntArray[j];
        array[j * 4] = (byte)((c & 0xFF000000) >> 24);
        array[j * 4 + 1] = (byte)((c & 0xFF0000) >> 16);
        array[j * 4 + 2] = (byte)((c & 0xFF00) >> 8);
        array[j * 4 + 3] = (byte)(c & 0xFF);
    }
    return array;
}

public static int[] convertToIntArray(final byte[] pByteArray)
{
    final int[] array = new int[pByteArray.length / 4];
    for (int i = 0; i < array.length; i++)
        array[i] = (((int)(pByteArray[i * 4]) << 24) & 0xFF000000) |
                (((int)(pByteArray[i * 4 + 1]) << 16) & 0xFF0000) |
                (((int)(pByteArray[i * 4 + 2]) << 8) & 0xFF00) |
                ((int)(pByteArray[i * 4 + 3]) & 0xFF);
    return array;
}

公共静态字节[]转换字节数组（final int[]pIntArray）
{
最终字节[]数组=新字节[pIntArray.length*4]；
对于（int j=0；j>24）；
数组[j*4+1]=（字节）（（c&0xFF0000）>>16）；
数组[j*4+2]=（字节）（（c&0xFF00）>>8）；
数组[j*4+3]=（字节）（c&0xFF）；
}
返回数组；
}
公共静态int[]convertToIntArray（最终字节[]pByteArray）
{
final int[]数组=新的int[pByteArray.length/4]；
for（int i=0；i
我明白你的意思，但是对于这个特殊的任务，“我的”代码比一些“魔法”ByteBuffer更具声明性和清晰性，你必须检查它的功能。@Kevin-这很苛刻-有很多情况下这种代码是合适的，例如在图像处理中。JDK库一般都很好，但它们不包括和/或并非针对所有用例都进行了优化。同意；与一些简单且众所周知的字节操作相比，ByteBuffer的开销和复杂性可能并不合适。我要补充的另一点是，您使用的是无符号右移运算符
>>
，而不是右移运算符
>
（）因此，有符号与无符号数字的行为可能不符合预期。这种方法似乎比前面提到的ByteBuffer或BigInteger方法快一点。如果要进行大量转换，还需要考虑一些其他因素。可能重复的可能重复或使用格式
“0x%02X”
如果您总是需要两个十六进制字符以及大写十六进制，例如
System.out.format（“0x%02X”，（字节）10）
显示
0x0A
@conor Javadoc表示allocateDirect（）确实有成本，应该在缓冲区保留一段时间时使用。虽然答案有效，但对于手头的用例来说似乎有点过分。您可以使用Integer.SIZE/8来避免硬编码4，这是一种适用于其他类型（如Long）的模式。@davenpcj您甚至可以使用Integer.SIZE/Byte。SIZE@rkosegi甚至是整数TES自Java 8:）您有什么保证可以生成一个4字节的数组？这正是MeBigFatGuy写的。Javadoc of
BigInteger.toByteArray（）
声明：“数组将包含表示此BigInteger所需的最小字节数…”在这个问题中，它要求字节数组的长度是否固定4？这取决于算法，这意味着你可以利用数组的长度。这是动态的，应该是正确的答案。如果你喜欢java，你可以简单地做一个数组附加来创建所需的大小。特别是当你必须考虑Java签名时。int值。这似乎为0x7f创建了一个字节，为0x80创建了两个字节（两个字节是：0x0 0x80）.ObjectOutputStream的使用不正确。使用DataOutputStream，OOS的使用使字节数组不是4字节。这将提取最低有效的8字节。它还避免将输入数字的符号拖到转换的八位字节中。-您能将此C#转换为Java吗？
byte[] IntToByteArray( int data ) {    
    byte[] result = new byte[4];
    result[0] = (byte) ((data & 0xFF000000) >> 24);
    result[1] = (byte) ((data & 0x00FF0000) >> 16);
    result[2] = (byte) ((data & 0x0000FF00) >> 8);
    result[3] = (byte) ((data & 0x000000FF) >> 0);
    return result;        
}

byte[] bytearray = Ints.toByteArray(1695609641);

public static byte[] convertToByteArray(final int[] pIntArray)
{
    final byte[] array = new byte[pIntArray.length * 4];
    for (int j = 0; j < pIntArray.length; j++)
    {
        final int c = pIntArray[j];
        array[j * 4] = (byte)((c & 0xFF000000) >> 24);
        array[j * 4 + 1] = (byte)((c & 0xFF0000) >> 16);
        array[j * 4 + 2] = (byte)((c & 0xFF00) >> 8);
        array[j * 4 + 3] = (byte)(c & 0xFF);
    }
    return array;
}

public static int[] convertToIntArray(final byte[] pByteArray)
{
    final int[] array = new int[pByteArray.length / 4];
    for (int i = 0; i < array.length; i++)
        array[i] = (((int)(pByteArray[i * 4]) << 24) & 0xFF000000) |
                (((int)(pByteArray[i * 4 + 1]) << 16) & 0xFF0000) |
                (((int)(pByteArray[i * 4 + 2]) << 8) & 0xFF00) |
                ((int)(pByteArray[i * 4 + 3]) & 0xFF);
    return array;
}

public static byte[] toByteArray(int value) {
    byte result[] = new byte[4];
    return Conversion.intToByteArray(value, 0, result, 0, 4);
}