我正在使用以下方式读取文件：
int len = (int)(new File(args[0]).length());
FileInputStream fis =
new FileInputStream(args[0]);
byte buf[] = new byte[len];
fis.read(buf);
我在这里找到了答案。是否可能将byte array buf转换为Int Array？将Byte Array转换为Int Array会占用显著更多的空间吗？
编辑：我的文件包含数百万个整数，例如
100000000 200000000 .....（使用普通int文件编写）。 我读取它到字节缓冲区中。现在我想将其包装到IntBuffer数组中。 如何做到这一点？ 我不想将每个字节转换为整数。
你在评论中提到希望从输入数组中获取四个字节与输出数组中的一个整数对应，这非常好。
取决于你期望字节是大端序还是小端序，但是......
IntBuffer intBuf =
ByteBuffer.wrap(byteArray)
.order(ByteOrder.BIG_ENDIAN)
.asIntBuffer();
int[] array = new int[intBuf.remaining()];
intBuf.get(array);
三行代码搞定。
int[] intArray = new int[byteArray.length]; for (int i = 0; i < byteArray.length; i++) { intArray[i] = byteArray[i]; } - Louis Wassermanpublic 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;
}
& 与 0xFF 结合使用的作用是什么？ - weima&的作用是防止所谓的“算术转换”。通常情况下，当进行强制类型转换(int) someByte时，它会保持符号，因此负数保持不变。这意味着如果字节的最前面有一个1，它将一直重复到整数的前面。位运算符&可以防止这种情况发生。我在 Pastebin 上有一个小的Java代码片段来展示其功能。如果您想要更多信息，请查找“二进制补码”。 - Christoph Fischer在Java中：
进行转换时，你可以这样做：
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]
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个字节表示一个整数。字节输入为byte[] srcByte。整数输出为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;
}
}
对于大端字节序，请替换此行：
for(shiftBits = 24; shiftBits >= 0; shiftBits -= 8) //Add in each data byte, highest first
请定义“显著”。在Java中，int类型占用4个字节，因此按定义，数组将占用4倍的空间。请参见：http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
在转换过程中，您必须同时拥有两者，因此在复制部分期间，如果您一次性复制整个数组，则会使用更多内存。
至于转换，有许多相关问题：
int数组，并复制值，根据需要进行类型转换。int[] arr = new int[len];
for(int i = 0; i < len; i++)
arr[i] = (int)buf[i];
int存储在32位上，而byte存储在8位上，因此它将占用大约4倍的空间。 - Pshemo4字节存储在一个int元素中吗？如果是这样的话，这篇文章可能会对你有帮助。 - Pshemo