Java 如何将字节数组转换为整数数组

我正在使用以下命令读取文件：

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

---

正如我发现的那样。是否可以将

字节数组buf

转换为

整数数组

？将

字节数组

转换为

Int数组

是否会占用更多空间

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

---

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

创建一个新的

int

数组并复制值，根据需要进行强制转换

int[] arr = new int[len];

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

int[]arr=newint[len]；
对于（int i=0；i

定义“显著”。在java中，int是4个字节，因此根据定义，数组是空间的4倍。见：

在转换过程中，您必须同时拥有这两个元素，因此在复制部分，如果您同时复制整个数组，您将使用更多的元素

至于转换，有许多相关问题：

---

将字节数组的每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;
}

public int[]转换（字节buf[]{
int intArr[]=新int[buf.length/4]；
整数偏移=0；
对于（int i=0；i

字节=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));

您在评论中说过，您希望输入数组中的四个字节对应于输出数组中的一个整数，这样就很好地解决了这个问题

这取决于您希望字节的顺序是大端还是小端，但是

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

完成，分三行。
这对您合适吗

    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;
    }

int-IntToByte（字节arrayDst[]，int-arrayOrg[]，int-maxOrg）{
int i；
int-idxDst；
int maxDst；
//
maxDst=maxOrg*4；
//
if（arrayDst==null）
返回0；
if（arrayOrg==null）
返回0；
if（阵列长度<最大值）
返回0；
if（arrayOrg.length8）；
idxDst++；
arrayDst[idxDst]=（字节）（arrayOrg[i]>>16）；
idxDst++；
arrayDst[idxDst]=（字节）（arrayOrg[i]>>24）；
idxDst++；
}
//
返回idxDst；
}
int-bytepoint（int-arrayDst[]，byte-arrayOrg[]，int-maxOrg）{
int i；
INTV；
int-idxOrg；
int maxDst；
//
maxDst=maxOrg/4；
//
if（arrayDst==null）
返回0；
if（arrayOrg==null）
返回0；
if（阵列长度<最大值）
返回0；
if（arrayOrg.length对于（i=0；i将字节数组转换为整数数组的解决方案，其中每组4个字节表示一个整数。字节输入为
byte[]srcByte
。整数输出为
dsint[]

Little endian源字节：

    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;
        }
    }

为什么要将字节数组转换为int数组？@vidit，这样我就可以读取int c=array[0]这样的整数，只需循环并将值复制到新的int数组？“将占用更多空间”每个
int
存储在32位上，
字节
存储在8位上，因此需要大约4倍的时间space@alessandro是否要将数组转换为将每个
4字节
s存储在一个
int
元素中？在这种情况下，您可能会感兴趣。我希望将4字节转换为int，而不是将单个字节转换为int。文件是int file。@alesandro：你是说你想让数组的每4个字节代表一个整数吗？
&
with
0xFF
的用法是什么是从字节数组创建int数组的小端方法。当然，这假设您希望将每组4个字节转换为int，而不是每个字节。是的，OP在对其他答案的注释中暗示了这一点。如何让上述方法将每个字节解释为一个int？4个字节的数组将变成4个字节的数组ints@typelogic：你不能这么做这样做。使用for循环的手册来做。
int[]intArray=newint[byteArray.length]；for（inti=0；i

    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;
        }
    }

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