三种访问文件的方式

标准IO,带缓冲的标准IO，内存映射等在Java中的实现：

package com.mesopotamia.test;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Scanner;

import org.apache.log4j.Logger;
/*
 * 原文学习请加微信订阅号：it_pupil
 * **/
public class FileRead {
    private static Logger logger = Logger.getLogger(FileRead.class); 
    public static void main(String args[]) throws FileNotFoundException{
        String path = "C:" + File.separator + "test" + File.separator + "Alice.txt";  
        readFile3(path);
    }
    
    public static void readFile(String path) throws FileNotFoundException {
        long start = System.currentTimeMillis();//开始时间
        int bufSize = 1024;//1K缓冲区
        File fin = new File(path); 
        /*
         * 通道就是为操作文件而建立的一个连接。（读写文件、内存映射等）
         * 此处的getChannel()可以获取通道；
         * 用FileChannel.open(filename)也可以创建一个通道。
         * "r"表示只读。
         * 
         * RandomAccessFile是独立与I/O流家族的类，其父类是Object。
         * 该类因为有个指针可以挪动，所以，可以从任意位置开始读取文件数据。
         * **/
        FileChannel fcin = new RandomAccessFile(fin, "r").getChannel();
        //给字节缓冲区分配大小
        ByteBuffer rBuffer = ByteBuffer.allocate(bufSize);                        
        String enterStr = "\n";
        try {
            byte[] bs = new byte[bufSize];
            String tempString = null;
            while (fcin.read(rBuffer) != -1) {//每次读1k到缓冲区
                int rSize = rBuffer.position();//记录缓冲区当前位置
                rBuffer.rewind();//位置归零，标记取消，方便下次循环重新读入缓冲区。
                rBuffer.get(bs);//将缓冲区数据读到字节数组中
                rBuffer.clear();//清除缓冲
                /*
                 * 用默认编码将指定字节数组的数据构造成一个字符串
                 * bs:指定的字节数组，0：数组起始位置；rSize：数组结束位置
                 * */
                tempString = new String(bs, 0, rSize);
                int fromIndex = 0;//每次读的开始位置
                int endIndex = 0;//每次读的结束位置
                //按行读String数据
                while ((endIndex = tempString.indexOf(enterStr, fromIndex)) != -1) {
                    String line = tempString.substring(fromIndex, endIndex);//转换一行            
                    System.out.print(line);                     
                    fromIndex = endIndex + 1;
                }
            }
            long end = System.currentTimeMillis();//结束时间
            System.out.println("传统IO读取数据,指定缓冲区大小，总共耗时："+(end - start)+"ms");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void readFile1(String path) { 
        long start = System.currentTimeMillis();//开始时间
        File file = new File(path);  
        if (file.isFile()) {  
            /*使用Reader家族，表示我要读字符数据了，
             *使用该家族中的BufferedReader，表示我要建立缓冲区读字符数据了。
             * */
            BufferedReader bufferedReader = null;  
            FileReader fileReader = null;  
            try {  
                fileReader = new FileReader(file); 
                //嵌套使用，装饰者模式，老生常谈。装饰者模式的使用，可以读前面小砖写的《从熏肉大饼到装饰者模式》
                bufferedReader = new BufferedReader(fileReader);  
                String line = bufferedReader.readLine();  
                //一行一行读
                while (line != null) { //按行读数据
                    System.out.println(line);  
                    line = bufferedReader.readLine();  
                }  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                //最后一定要关闭
                try {  
                    fileReader.close();  
                    bufferedReader.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
                long end = System.currentTimeMillis();//结束时间
                System.out.println("传统IO读取数据，不指定缓冲区大小，总共耗时："+(end - start)+"ms");
            }  
  
        }  
    } 
    
    public static void readFile3(String path) {
        long start = System.currentTimeMillis();//开始时间
        long fileLength = 0;  
        final int BUFFER_SIZE = 0x300000;// 3M的缓冲  
            File file = new File(path);  
            fileLength = file.length();  
            try {  
                /*使用FileChannel.map方法直接把整个fileLength大小的文件映射到内存中**/
                MappedByteBuffer inputBuffer = new RandomAccessFile(file, "r").getChannel()
                    .map(FileChannel.MapMode.READ_ONLY, 0, fileLength);// 读取大文件  
                byte[] dst = new byte[BUFFER_SIZE];// 每次读出3M的内容
                //每3M做一个循环，分段将inputBuffer的数据取出。
                for (int offset = 0; offset < fileLength; offset += BUFFER_SIZE) {
                    //防止最后一段不够3M
                    if (fileLength - offset >= BUFFER_SIZE) {
                        //一个字节一个字节的取出来放到byte[]数组中。
                        for (int i = 0; i < BUFFER_SIZE; i++)  
                            dst[i] = inputBuffer.get(offset + i);  
                    } else {  
                        for (int i = 0; i < fileLength - offset; i++)  
                            dst[i] = inputBuffer.get(offset + i);  
                    }  
                    // 将得到的3M内容给Scanner，这里的XXX是指Scanner解析的分隔符。
                    Scanner scan = new Scanner(new ByteArrayInputStream(dst)).useDelimiter("XXX");  
                    //hasNext()所参照的token就是上面的XXX
                    while (scan.hasNext()) {  
                        // 这里为对读取文本解析的方法  
                        System.out.print(scan.next() + "XXX");  
                    }  
                    scan.close();  
                }  
                System.out.println();
                long end = System.currentTimeMillis();//结束时间
                System.out.println("NIO 内存映射读大文件，总共耗时："+(end - start)+"ms");
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
    } 
}

内容来自：《磁盘IO的工作机制》，发布自微信订阅号：it_pupil

《磁盘IO的工作机制》主要内容：

　　内核空间与用户空间（以及数据在二者之间的转换）；

　　标准访问文件的方式（要同时经过内核空间、用户空间的双重拷贝）（局部性原理）；

　　带缓冲访问文件的方式；

　　直接IO（避开内核缓冲区，适合在应用程序中管理缓存的系统，比如：数据库管理系统）;

　　内存映射（磁盘文件与用户空间的直接映射，减少拷贝数据的次数，适合大文件的读写。）；

　　阻塞与非阻塞，同步与异步的区分（非阻塞同步、非阻塞异步的介绍）；

订阅号二维码：