将文件的一部分复制到Java中的字节数组

Question

Is there any way to read part of a file to be imported into a byte array?

I would like to know how, because I can only found ways to convert the whole file into a byte array which is a very heavy memory hungry operation.

Answer 1

I'd use RandomAccessFile :

public static byte[] readFileSegment(File file, long index, int count) {
    RandomAccessFile raf = new RandomAccessFile(file, "r");
    byte[] buffer = new byte[count];
    try {
        raf.seek(index);
        raf.readFully(buffer, 0, count);
        return buffer;
    } finally {
        raf.close();
    }
}

There are other alternatives with memory mapped files, NIO etc - but this should be simple.

Answer 2

You can use a RandomAccessFile, or a FileInputStream with skip.

My favourite is to use a memory mapped file as it only loads into memory what you use and uses almost no heap (regardless of how much you use)

Answer 3

This actually worked for me in the way that i needed to get the beginning part of a file up to a certain byte size:

try
{
   int myDesiredCapacity = 100000; // 100KB
   FileInputStream is = new FileInputStream(otherFile);

   FileChannel fileChannel = is.getChannel();
   ByteBuffer byteBuffer = ByteBuffer.allocate(myDesiredCapacity);

   byte[] bytes;

   int byteCount = fileChannel.read(bb);
   if(byteCount >= 0)
   {
        bb.flip();
        bytes = bb.array();
        FileOutputStream fileOutputStream = new FileOutputStream(targetFile);
        fileOutputStream.write(bytes);
        fileOutputStream.close();
        bb.clear();
    }
}

catch(IOException e)
{
    e.printStackTrace();
}

Answer 4

Sure - you perform roughly the same steps as you would do to read the whole file to a byte array, except that you throw away the part of the file you want instead of adding them to the array.

This raises the very relevant question of how you will detect the boundaries of the section you want. If it's something like a particular sentinel byte (eg 11111111 ) then this is trivially easy. It's even easier if you want some fixed offsets, just discard the first n bytes and then store the following m bytes.

If however you're detecting some sort of byte sequence then things get a little more involved, as you'll have to maintain a local variable of the part that's matched so far, then discard this if it doesn't match the whole sequence or add it all to the output if the whole sequence turns out to match.

At the end of the day though, the concept is straightforward - read the bytes from the file as you would if you were loading all of it, but only actually put them in the output array if they're the part you want.