1. java 读取大文件的困难
java 读取文件的一般操作是将文件数据全部读取到内存中，然后再对数据进行操作。例如
Path path = Paths.get("file path");
byte[] data = Files.readAllBytes(path);
这对于小文件是没有问题的，但是对于稍大一些的文件就会抛出异常
Exception in thread"main"java.lang.OutOfMemoryError: Required array size too large
at java.nio.file.Files.readAllBytes(Files.java:3156)
从错误定位看出，Files.readAllBytes方法最大支持Integer.MAX_VALUE - 8大小的文件，也即最大2GB的文件。一旦超过了这个限度，java 原生的方法就不能直接使用了。
既然不能直接全部读取大文件到内存中，那么就应该把文件分成多个子区域分多次读取。这就会有多种方法可以使用。
对文件建立java.io.BufferedInputStream，每次调用read()方法时会接连取出文件中长度为arraySize的数据到array中。这种方法可行但是效率不高。
importjava.io.BufferedInputStream;
importjava.io.FileInputStream;
importjava.io.IOException;
/**
* Created by
*/
publicclassStreamFileReader{
privateBufferedInputStream fileIn;
privatelongfileLength;
privateintarraySize;
privatebyte[] array;
publicStreamFileReader(String fileName,intarraySize)throwsIOException{
this.fileIn =newBufferedInputStream(newFileInputStream(fileName), arraySize);
this.fileLength = fileIn.available();
this.arraySize = arraySize;
? ? }
publicintread()throwsIOException{
byte[] tmpArray =newbyte[arraySize];
intbytes = fileIn.read(tmpArray);// 暂存到字节数组中
if(bytes != -1) {
array =newbyte[bytes];// 字节数组长度为已读取长度
System.arraycopy(tmpArray,0, array,0, bytes);// 复制已读取数据
returnbytes;
? ? ? ? }
return-1;
? ? }
publicvoidclose()throwsIOException{
? ? ? ? fileIn.close();
array =null;
? ? }
publicbyte[] getArray() {
returnarray;
? ? }
publiclonggetFileLength(){
returnfileLength;
? ? }
publicstaticvoidmain(String[] args)throwsIOException{
StreamFileReader reader =newStreamFileReader("/home/zfh/movie.mkv",65536);
longstart = System.nanoTime();
while(reader.read() != -1) ;
longend = System.nanoTime();
? ? ? ? reader.close();
System.out.println("StreamFileReader: "+ (end - start));
? ? }
}
对文件建立java.nio.channels.FileChannel，每次调用read()方法时会先将文件数据读取到分配的长度为arraySize的java.nio.ByteBuffer中，再从中将已经读取到的文件数据转化到array中。这种利用了NIO中的通道的方法，比传统的字节流读取文件是要快一些。
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.nio.ByteBuffer;
importjava.nio.channels.FileChannel;
/**
* Created by
*/
publicclassChannelFileReader{
privateFileInputStream fileIn;
privateByteBuffer byteBuf;
privatelongfileLength;
privateintarraySize;
privatebyte[] array;
publicChannelFileReader(String fileName,intarraySize)throwsIOException{
this.fileIn =newFileInputStream(fileName);
this.fileLength = fileIn.getChannel().size();
this.arraySize = arraySize;
this.byteBuf = ByteBuffer.allocate(arraySize);
? ? }
publicintread()throwsIOException{
? ? ? ? FileChannel fileChannel = fileIn.getChannel();
intbytes = fileChannel.read(byteBuf);// 读取到ByteBuffer中
if(bytes != -1) {
array =newbyte[bytes];// 字节数组长度为已读取长度
? ? ? ? ? ? byteBuf.flip();
byteBuf.get(array);// 从ByteBuffer中得到字节数组
? ? ? ? ? ? byteBuf.clear();
returnbytes;
? ? ? ? }
return-1;
? ? }
publicvoidclose()throwsIOException{
? ? ? ? fileIn.close();
array =null;
? ? }
publicbyte[] getArray() {
returnarray;
? ? }
publiclonggetFileLength(){
returnfileLength;
? ? }
publicstaticvoidmain(String[] args)throwsIOException{
ChannelFileReader reader =newChannelFileReader("/home/zfh/movie.mkv",65536);
longstart = System.nanoTime();
while(reader.read() != -1) ;
longend = System.nanoTime();
? ? ? ? reader.close();
System.out.println("ChannelFileReader: "+ (end - start));
? ? }
}
这种方法就是把文件的内容被映像到计算机虚拟内存的一块区域，从而可以直接操作内存当中的数据而无需每次都通过 I/O 去物理硬盘读取文件。这是由当前 java 态进入到操作系统内核态，由操作系统读取文件，再返回数据到当前 java 态的过程。这样就能大幅提高我们操作大文件的速度。
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.nio.MappedByteBuffer;
importjava.nio.channels.FileChannel;
/**
* Created by
*/
publicclassMappedFileReader{
privateFileInputStream fileIn;
privateMappedByteBuffer mappedBuf;
privatelongfileLength;
privateintarraySize;
privatebyte[] array;
publicMappedFileReader(String fileName,intarraySize)throwsIOException{
this.fileIn =newFileInputStream(fileName);
? ? ? ? FileChannel fileChannel = fileIn.getChannel();
this.fileLength = fileChannel.size();
this.mappedBuf = fileChannel.map(FileChannel.MapMode.READ_ONLY,0, fileLength);
this.arraySize = arraySize;
? ? }
publicintread()throwsIOException{
intlimit = mappedBuf.limit();
intposition = mappedBuf.position();
if(position == limit) {
return-1;
? ? ? ? }
if(limit - position > arraySize) {
array =newbyte[arraySize];
? ? ? ? ? ? mappedBuf.get(array);
returnarraySize;
}else{// 最后一次读取数据
array =newbyte[limit - position];
? ? ? ? ? ? mappedBuf.get(array);
returnlimit - position;
? ? ? ? }
? ? }
publicvoidclose()throwsIOException{
? ? ? ? fileIn.close();
array =null;
? ? }
publicbyte[] getArray() {
returnarray;
? ? }
publiclonggetFileLength(){
returnfileLength;
? ? }
publicstaticvoidmain(String[] args)throwsIOException{
MappedFileReader reader =newMappedFileReader("/home/zfh/movie.mkv",65536);
longstart = System.nanoTime();
while(reader.read() != -1);
longend = System.nanoTime();
? ? ? ? reader.close();
System.out.println("MappedFileReader: "+ (end - start));
? ? }
}
看似问题完美解决了，我们肯定会采用内存文件映射的方法去处理大文件。但是运行结果发现，这个方法仍然不能读取超过2GB的文件，明明FileChannel.map()方法传递的文件长度是long类型的，怎么和Integer.MAX_VALUE有关系？
Exception in thread"main"java.lang.IllegalArgumentException: Size exceeds Integer.MAX_VALUE
at sun.nio.ch.FileChannelImpl.map(FileChannelImpl.java:868)
再从错误定位可以看到
size - The size of the region to be mapped; must be non-negative and no greater than Integer.MAX_VALUE
这可以归结到一些历史原因，还有int类型在 java 中的深入程度，但是本质上由于java.nio.MappedByteBuffer是直接继承自java.nio.ByteBuffer的，而后者的索引变量是int类型的，所以前者也只能最大索引到Integer.MAX_VALUE的位置。这样的话我们是不是就没有办法了？当然不是，一个内存文件映射不够用，那么试一试用多个就可以了。
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.nio.MappedByteBuffer;
importjava.nio.channels.FileChannel;
/**
* Created by
*/
publicclassMappedBiggerFileReader{
privateMappedByteBuffer[] mappedBufArray;
privateintcount =0;
privateintnumber;
privateFileInputStream fileIn;
privatelongfileLength;
privateintarraySize;
privatebyte[] array;
publicMappedBiggerFileReader(String fileName,intarraySize)throwsIOException{
this.fileIn =newFileInputStream(fileName);
? ? ? ? FileChannel fileChannel = fileIn.getChannel();
this.fileLength = fileChannel.size();
this.number = (int) Math.ceil((double) fileLength / (double) Integer.MAX_VALUE);
this.mappedBufArray =newMappedByteBuffer[number];// 内存文件映射数组
longpreLength =0;
longregionSize = (long) Integer.MAX_VALUE;// 映射区域的大小
for(inti =0; i < number; i++) {// 将文件的连续区域映射到内存文件映射数组中
if(fileLength - preLength < (long) Integer.MAX_VALUE) {
regionSize = fileLength - preLength;// 最后一片区域的大小
? ? ? ? ? ? }
? ? ? ? ? ? mappedBufArray[i] = fileChannel.map(FileChannel.MapMode.READ_ONLY, preLength, regionSize);
preLength += regionSize;// 下一片区域的开始
? ? ? ? }
this.arraySize = arraySize;
? ? }
publicintread()throwsIOException{
if(count >= number) {
return-1;
? ? ? ? }
intlimit = mappedBufArray[count].limit();
intposition = mappedBufArray[count].position();
if(limit - position > arraySize) {
array =newbyte[arraySize];
? ? ? ? ? ? mappedBufArray[count].get(array);
returnarraySize;
}else{// 本内存文件映射最后一次读取数据
array =newbyte[limit - position];
? ? ? ? ? ? mappedBufArray[count].get(array);
if(count < number) {
count++;// 转换到下一个内存文件映射
? ? ? ? ? ? }
returnlimit - position;
? ? ? ? }
? ? }
publicvoidclose()throwsIOException{
? ? ? ? fileIn.close();
array =null;
? ? }
publicbyte[] getArray() {
returnarray;
? ? }
publiclonggetFileLength(){
returnfileLength;
? ? }
publicstaticvoidmain(String[] args)throwsIOException{
MappedBiggerFileReader reader =newMappedBiggerFileReader("/home/zfh/movie.mkv",65536);
longstart = System.nanoTime();
while(reader.read() != -1) ;
longend = System.nanoTime();
? ? ? ? reader.close();
System.out.println("MappedBiggerFileReader: "+ (end - start));
? ? }
}
用上面三种方法读取1GB文件，运行结果如下
StreamFileReader:11494900386
ChannelFileReader:11329346316
MappedFileReader:11169097480
读取10GB文件，运行结果如下
StreamFileReader:194579779394
ChannelFileReader:190430242497
MappedBiggerFileReader:186923035795
