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();

            }

    }

}