java利用“映射文件访问”（MapperByteBuffer）处理文件与单纯利用Buffer来处理文件的快慢比较

　　处理文件是java经常使用的操作，在对一个“大文件”（比如超过64M）进行操作时一点点速度的提高都会带来性能的巨大提升。然而我们经常使用的BufferxxStream，来直接处理大文件时，往往力不从心。

　　java中“映射文件访问”机制则解决了这一问题，它把大文件的较小部分先放在内存里，将其余待读取的数据仍然放在硬盘里面。但是我们完全可以通过这样一个机制把这个大文件当作非常大的数组来使用。是不是很像操作系统里面对于应用的使用方法？没错，其实java正是利用了底层操作系统的文件映射工具来最大化提高性能。

　　一般为了即能读又能写，我们使用RandomAccessFile来进行测试，同过该文件上的通道，然后调用FileChannel中的map()所产生的MappedByteBuffer，在map方法中有三个参数map(FileChannel.MapMode mode, long position, long size)。

　　其中mode 来决定映射的文件访问的读/写机制，可以设置MapMode.READ_ONLY， MapMode.READ_WRITE，MapMode.PRIVATE，通过名字可以看得出他们的作用，特别要注意MapMode.PRIVATE方法，如何你操作不当会导致你操作的文件无法被共享。

　　而position为区域内的文件映射的位置开始,必须是非负数

　　size为区域的大小是映射;必须是非负数,不大于Integer.MAX_VALUE

　　其实position和size的设置就意味着我们映射某个大文件的较小的部分

　　下面就来看我们使用了“映射文件访问”时，的性能提升把！

　　以下是代码部分：

 package com.company;

 import java.io.*;
 import java.nio.IntBuffer;
 import java.nio.channels.FileChannel;

 /**
  * Created by chunmiao on 17-3-15.
  */
 public class MappedIOTest {
     //输入值的数量
     private static int numOfInts = 4000000;
     //测试读写值的数量大小
     private static int numOfUbuffInts = 200000;

     private abstract static class Tester{
         private String name;
         public Tester(String name){
             this.name = name;
         }

         //测试计时
         public void runTest(){
             System.out.println(name + ": ");
             try {
                 long start = System.nanoTime();
                 test();
                 long runtime = System.nanoTime() - start;
                 //输出test（）运行时间，来判定操作时间大小
                 System.out.format("%.2f\n",runtime/1.0e9);
             }catch (IOException e){
                 throw new RuntimeException(e);
             }
         }

         public abstract void test() throws IOException;
     }

     private static Tester[] tests = {
             //直接写入数据
             new Tester("Stream Write") {
                 @Override
                 public void test() throws IOException {
                     DataOutputStream dos = new DataOutputStream(
                             new BufferedOutputStream(
                                     new FileOutputStream(new File("temp.tmp"))));
                     for (int i = 0; i < numOfInts; i ++){
                         dos.writeInt(i);
                     }
                     dos.close();
                 }
             },
             //使用MappedByteBuffer进行写文件操作
             new Tester("Mapped Write") {
                 @Override
                 public void test() throws IOException {
                     FileChannel fc = new RandomAccessFile("temp.tmp","rw").getChannel();
                     //fc.size()返回的是以byte为单位的数量值。
                     IntBuffer ib = fc.map(FileChannel.MapMode.READ_WRITE,0,fc.size()).asIntBuffer();
                     for(int i =0 ; i < numOfInts ; i ++){
                         try {
                             ib.put(i);
                         }catch (Exception e){
                             System.out.println(i);
                         }
                     }
                     fc.close();
                 }
             },
             //直接读数据
             new Tester("Stream Read") {
                 @Override
                 public void test() throws IOException {
                     DataInputStream dis = new DataInputStream(
                             new BufferedInputStream(new FileInputStream("temp.tmp")));
                     for (int i = 0 ; i < numOfInts ; i ++){
                         dis.readInt();
                     }
                     dis.close();
                 }
             },
             //使用MappedByteBuffer进行读文件操作
             new Tester("Mapped Read") {
                 @Override
                 public void test() throws IOException {
                     FileChannel fc = new FileInputStream(new File("temp.tmp")).getChannel();
                     IntBuffer ib = fc.map(FileChannel.MapMode.READ_ONLY,0,fc.size()).asIntBuffer();
                     while (ib.hasRemaining()){
                         ib.get();
                     }
                     fc.close();
                 }
             },
             //直接进行读/写操作
             new Tester("Stream Read/Write") {
                 @Override
                 public void test() throws IOException {
                     RandomAccessFile raf = new RandomAccessFile(new File("temp.tmp"),"rw");
                     //对数据进行进行错位，以便同时进行读写操作
                     raf.writeInt(1);
                     for (int i = 0 ; i < numOfUbuffInts ; i ++){
                         //之所以减4的原因是raf.length()返回以byte为单位的空间大小，而1 （int） = 4 （byte）,因此需要减4
                         raf.seek(raf.length() - 4);
                         raf.writeInt(raf.readInt());
                     }
                     raf.close();
                 }
             },
             //使用MappedByteBuffer进行读/写操作
             new Tester("Mapped Read/Write") {
                 @Override
                 public void test() throws IOException {
                     FileChannel fc = new RandomAccessFile(new File("temp.tmp"),"rw").getChannel();
                     IntBuffer ib = fc.map(FileChannel.MapMode.READ_WRITE,0,fc.size()).asIntBuffer();
                     ib.put(0);
                     for (int i = 1 ; i < numOfUbuffInts ; i ++){
                         //对数据进行进行错位，以便同时进行读写操作
                         ib.put(ib.get(i - 1));
                     }
                     fc.close();
                 }
             }
     };

     public static void main(String[] args) {
         //进行测试
         for (Tester tester : tests){
             tester.runTest();
         }
     }
 }

以下是运行结果：