如何将字节数组转换为整数数组答案

【问题标题】：How to convert a Byte Array to an Int Array如何将字节数组转换为整数数组
【发布时间】：2012-07-11 08:09:03
【问题描述】：

我正在使用以下方式读取文件：

int len = (int)(new File(args[0]).length());
    FileInputStream fis =
        new FileInputStream(args[0]);
    byte buf[] = new byte[len];
    fis.read(buf);

我发现here。是否可以将 byte array buf 转换为 Int Array ？将Byte Array 转换为Int Array 会占用更多空间吗？

编辑：我的文件包含数百万个整数，例如，

100000000 200000000 .....（使用普通 int 文件写入）。我把它读到字节缓冲区。现在我想将它包装到 IntBuffer 数组中。怎么做？我不想将每个字节转换为 int。

【问题讨论】：

为什么要将字节数组转换为int数组？
@vidit，因此我可以读取整数，如 int c = array[0]
只是循环并将值复制到一个新的 int 数组中？
“将占用更多空间”每个int 存储在 32 位上，byte 存储在 8 位上，因此将占用大约 4 倍的空间
@alessandro 是否要将数组转换为将每个4 bytes 存储在一个int 元素中？在这种情况下，this 你可能会感兴趣。

标签： java arrays int byte endianness

【解决方案1】：

您在 cmets 中说过，您希望输入数组中的四个字节对应于输出数组中的一个整数，这样效果很好。

取决于您希望字节是大端还是小端，但是...

 IntBuffer intBuf =
   ByteBuffer.wrap(byteArray)
     .order(ByteOrder.BIG_ENDIAN)
     .asIntBuffer();
 int[] array = new int[intBuf.remaining()];
 intBuf.get(array);

完成，分三行。

【讨论】：

这当然假设您希望将每组 4 个字节转换为一个 int，而不是每个字节。
是的，OP 在 cmets 中暗示其他答案。
如何让上面的每个字节解释为一个int？ 4 个字节的数组变成了 4 个整数的数组
@typelogic：你不能那样做。使用手动 for 循环来完成。 int[] intArray = new int[byteArray.length]; for (int i = 0; i < byteArray.length; i++) { intArray[i] = byteArray[i]; }

【解决方案2】：

将字节数组的每4个字节转换为整数数组：

public int[] convert(byte buf[]) {
   int intArr[] = new int[buf.length / 4];
   int offset = 0;
   for(int i = 0; i < intArr.length; i++) {
      intArr[i] = (buf[3 + offset] & 0xFF) | ((buf[2 + offset] & 0xFF) << 8) |
                  ((buf[1 + offset] & 0xFF) << 16) | ((buf[0 + offset] & 0xFF) << 24);  
   offset += 4;
   }
   return intArr;
}

【讨论】：

我想要 4 字节转换为 int。不是单字节到 int。该文件是 int 文件。
@alessandro：你是说你想让数组的每 4 个字节代表一个整数？
&和0xFF有什么用
使用 & 和 0xFF（十进制：255 和二进制：11111111）是从字节数组创建 int 数组的小端方法。
@weima 位与运算符& 的要点是防止您所谓的“算术转换”。通常在投射(int) someByte 时它会保持符号，所以负数保持不变。这意味着如果字节的最前面有一个 1，它将一直重复到整数的前面。按位 & 可以防止这种情况。我在Pastebin 上有一个小的java coden-p 来显示功能。如果您想了解更多信息，请查看“二的补码”

【解决方案3】：

这适合你吗？

    int IntToByte(byte arrayDst[], int arrayOrg[], int maxOrg){
        int i;
        int idxDst;
        int maxDst;
        //
        maxDst = maxOrg*4;
        //
        if (arrayDst==null)
            return 0;
        if (arrayOrg==null)
            return 0;
        if (arrayDst.length < maxDst)
            return 0;
        if (arrayOrg.length < maxOrg)
            return 0;
        //
        idxDst = 0;
        for (i=0; i<maxOrg; i++){
            // Copia o int, byte a byte.
            arrayDst[idxDst] = (byte)(arrayOrg[i]);
            idxDst++;
            arrayDst[idxDst] = (byte)(arrayOrg[i] >> 8);
            idxDst++;
            arrayDst[idxDst] = (byte)(arrayOrg[i] >> 16);
            idxDst++;
            arrayDst[idxDst] = (byte)(arrayOrg[i] >> 24);
            idxDst++;
        }
        //
        return idxDst;
    }

    int ByteToInt(int arrayDst[], byte arrayOrg[], int maxOrg){
        int i;
        int v;
        int idxOrg;
        int maxDst;
        //
        maxDst = maxOrg/4;
        //
        if (arrayDst==null)
            return 0;
        if (arrayOrg==null)
            return 0;
        if (arrayDst.length < maxDst)
            return 0;
        if (arrayOrg.length < maxOrg)
            return 0;
        //
        idxOrg = 0;
        for (i=0; i<maxDst; i++){
            arrayDst[i] = 0;
            //
            v = 0x000000FF & arrayOrg[idxOrg];
            arrayDst[i] = arrayDst[i] | v;
            idxOrg++;
            //
            v = 0x000000FF & arrayOrg[idxOrg];
            arrayDst[i] = arrayDst[i] | (v << 8);
            idxOrg++;
            //
            v = 0x000000FF & arrayOrg[idxOrg];
            arrayDst[i] = arrayDst[i] | (v << 16);
            idxOrg++;
            //
            v = 0x000000FF & arrayOrg[idxOrg];
            arrayDst[i] = arrayDst[i] | (v << 24);
            idxOrg++;
        }
        //
        return maxDst;
    }

【讨论】：

【解决方案4】：

创建一个新的int 数组并复制值，根据需要进行强制转换。

int[] arr = new int[len];

for(int i = 0; i < len; i++)
    arr[i] = (int)buf[i];

【讨论】：

【解决方案5】：

定义“显着”。在 java 中，一个 int 是 4 个字节，因此根据定义，数组将是 4 倍的空间。见：http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

在转换过程中，你必须同时拥有两者，所以在复制部分，如果你一次复制整个数组，你会使用更多。

【讨论】：

【解决方案6】：

在java中：

字节 = 8 位
整数 = 32 位

对于转换，您可以执行以下操作：

byte[] byteArray = new byte[] {123, 12, 87};
int[] intArray = new int[byteArray.length];

// converting byteArray to intArray
for (int i = 0; i < byteArray.length; intArray[i] = byteArray[i++]);

System.out.println(Arrays.toString(intArray));

这将输出：

[123, 12, 87]

【讨论】：

【解决方案7】：

将字节数组转换为整数数组的解决方案，其中每组 4 个字节代表一个整数。字节输入是byte[] srcByte。 int 输出为dstInt[]。

小端源字节：

    int shiftBits;
    int byteNum = 0;
    int[] dstInt = new int[srcByte.length/4]; //you might have to hard code the array length

    //Convert array of source bytes (srcByte) into array of integers (dstInt)
    for (int intNum = 0; intNum < srcByte.length/4; ++intNum) {  //for the four integers
        dstInt[intNum] = 0;                                      //Start with the integer = 0

        for(shiftBits = 0; shiftBits < 32; shiftBits += 8) {     //Add in each data byte, lowest first
            dstInt[intNum] |= (srcByte[byteNum++] & 0xFF) << shiftBits;
        }
    }

对于 Big-Endian 替换此行：

    for(shiftBits = 24; shiftBits >= 0; shiftBits -= 8)  //Add in each data byte, highest first

【讨论】：