5

我必须读取一个文件，在每次迭代中我必须从文件中读取 8 个字节。例如，在第一次迭代中，我将读取前 8 个字节，在第二次迭代中读取接下来的 8 个字节，依此类推。如何在 Java 中做到这一点？

public static byte[] toByteArray(File file) {
    long length = file.length();
    byte[] array = new byte[length];
    InputStream in = new FileInputStream(file);
    long offset = 0;
    while (offset < length) {
        int count = in.read(array, offset, (length - offset));
        offset += length;
    }
    in.close();
    return array;
}

我发现了这一点，但我认为这段代码正在做的是完全读取文件并制作文件数据的字节数组。但是我只需要在一次迭代中准备好我需要的那么多字节。

4

5 回答 5

3

使用DataInput进行此类处理：

  private void process(File file) throws IOException {
    try (RandomAccessFile data = new RandomAccessFile(file, "r")) {
      byte[] eight = new byte[8];
      for (long i = 0, len = data.length() / 8; i < len; i++) {
        data.readFully(eight);
        // do something with the 8 bytes
      }
    }
  }

我使用了RandomAccessFile但DataInputStream是一种常见的替代方法。

于 2013-09-15T11:41:46.177 回答
2

您可以轻松地根据您的需要调整代码：添加偏移量和计数，并调用skip以超过初始N字节，如下所示 -

public static byte[] toByteArray(File file, long start, long count) {
      long length = file.length();
      if (start >= length) return new byte[0];
      count = Math.min(count, length - start);
      byte[] array = new byte[count];
      InputStream in = new FileInputStream(file);
      in.skip(start);
      long offset = 0;
      while (offset < count) {
          int tmp = in.read(array, offset, (length - offset));
          offset += tmp;
      }
      in.close();
      return array;
}
于 2013-09-15T11:10:23.583 回答
0

将代码分成小块，例如，要读取一个字节块（在您的情况下为 8 个字节），您需要知道 3 件事：

  1. 在哪个文件中读取
  2. 从哪里开始阅读
  3. 要读取多少字节/块的大小

将此视为一个步骤将为您提供一种返回 byte[] 数组的方法，将上述 3 个点作为参数，例如：

private byte[] readByteBlock(InputStream in, int offset, int noBytes) throws IOException {
    byte[] result = new byte[noBytes];
    in.read(result, offset, noBytes);
    return result;
}

下一步是打开文件并为文件中的每个字节块调用此方法。您从位置 0 开始读取文件，调用该方法一次，对结果执行一些操作，然后在位置 = (previousPos) + blockSize 处重新调用它。这段代码可以放在另一种方法中，例如：

public byte[][] toByteArray(File file, int byteBlockSize) throws IOException {

    InputStream in = new FileInputStream(file);
    long noOfBlocks = (long) Math.ceil((double)file.length() / (double)byteBlockSize);
    byte[][] result = new byte[(int)noOfBlocks][byteBlockSize];
    int offset = 0;
    for(int i = 0; i < result.length; i++) {
        result[i] = readByteBlock(in, offset, byteBlockSize);
    }
    return result;
}

这将返回一个 byte[][] 数组，第一个索引为 byteBlockNumber（前 8 个字节，第二个 8 个字节，第三个 8 个字节，...），第二个索引为每个单独的字节：

byte[0][0]: the first byte block's first byte
byte[0][7]: the first byte block's second byte
byte[1][2]: the second byte block, third byte
etc..

在上面的示例代码中，byte[][] 数组的初始化如下：

long noOfBlocks = (long) Math.ceil((double)file.length() / (double)byteBlockSize);
byte[][] result = new byte[noOfBlocks][byteBlockSize];

因此，块数是文件中的总字节数除以字节块的大小（在您的示例中为 8）。假设文件有 9 个字节并且块大小为 8，这将导致 1,sth 并四舍五入为 1，所以最后一个字节没有空间，这就是为什么 Math.ceil() 用于四舍五入的原因该师给出。Math.ceil(9 / 8) -> 2，这 2 个足以容纳 8 个字节的第一个块，以及第二个块中的最后一个字节。

于 2013-09-15T11:42:57.270 回答
0 
public static void main(String[] args) {
   File dir = new File("C:\\");
   int fixedNumber = n;
   if (dir.isDirectory()) {
      for (String file : dir.list()) {
         int sum = sumByteArray(new File(dir.getAbsoluteFile() + "\\" + file),fixedNumber);
      }
   }
}

private static int sumByteArray(File file, int fixedNumber) {
   FileInputStream fileInputStream = null;
   byte[] bFile = new byte[fixedNumber];
   int sum = 0;
   try {
      fileInputStream = new FileInputStream(file);
      fileInputStream.read(bFile);
      fileInputStream.close();
      for (Byte b : bFile) {
         sum += (int) b;
      }
   } 
   catch (Exception e) {
      e.printStackTrace();
   }
   return sum;
}
于 2019-10-25T05:52:00.643 回答
0

您可以使用以下代码读取具有起始偏移量和大小的内存块：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileReadingUtilities
{
    public static byte[] readBytes(String file, int start, int size) throws IOException
    {
        Path filePath = Paths.get(file);
        long fileSize = Files.size(filePath);

        if(start < 0)
        {
            throw new IllegalArgumentException("The start may not be negative!");
        }

        if(size < 0)
        {
            throw new IllegalArgumentException("The size may not be negative!");
        }

        if (start + size > fileSize)
        {
            throw new IllegalArgumentException("Interval exceeds file size!");
        }

        byte[] readBytes = new byte[size];

        try (InputStream inputStream = new FileInputStream(filePath.toFile()))
        {
            long actuallySkipped = inputStream.skip(start);

            if (start != actuallySkipped)
            {
                throw new IllegalStateException("Error while skipping bytes ahead!");
            }

            int bytesReadCount = inputStream.read(readBytes, 0, size);
            if (bytesReadCount != size)
            {
                throw new IllegalStateException("Not enough bytes have been read!");
            }
        }

        return readBytes;
    }
}

在性能方面甚至更好，请使用MappedByteBuffer：

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileReadingUtilities
{
    public static ByteBuffer getByteBuffer(String filePath, int start, int size) throws IOException
    {
        File binaryFile = new File(filePath);
        FileChannel binaryFileChannel = new RandomAccessFile(binaryFile, "r").getChannel();

        return binaryFileChannel.map(FileChannel.MapMode.READ_ONLY, start, size);
    }
}

字节数组可以通过ByteBuffer使用它的array()方法来访问。

于 2017-04-25T19:32:23.350 回答