程序博客网 > 绣春刀2影评知乎

Java文件读写IO/NIO及性能比较总结

来源：互联网 发布：绣春刀2影评知乎 编辑：程序博客网 时间：2024/06/06 09:49

干Java这么久，一直在做WEB相关的项目，一些基础类差不多都已经忘记。经常想得捡起，但总是因为一些原因，不能如愿。

其实不是没有时间，只是有些时候疲于总结，今得空，下定决心将丢掉的都给捡起来。

文件读写是一个在项目中经常遇到的工作，有些时候是因为维护，有些时候是新功能开发。我们的任务总是很重，工作节奏很快，快到我们不能停下脚步去总结。

文件读写有以下几种常用的方法

1、字节读写（InputStream/OutputStream）

2、字符读取（FileReader/FileWriter）

3、行读取（BufferedReader/BufferedWriter）

代码（以读取为例）：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. import java.io.BufferedReader;  
  2. import java.io.File;  
  3. import java.io.FileInputStream;  
  4. import java.io.FileReader;  
  5. import java.io.IOException;  
  6. import java.io.InputStream;  
  7. /** 
  8.  * <b>文件读取类</b><br /> 
  9.  * 1、按字节读取文件内容<br /> 
  10.  * 2、按字符读取文件内容<br /> 
  11.  * 3、按行读取文件内容<br /> 
  12.  * @author qin_xijuan 
  13.  * 
  14.  */  
  15. public class FileOperate {  
  16.       
  17.     private static final String FILE_PATH = "d:/work/the List of Beautiful Music.txt";  
  18.   
  19.     /** 
  20.      * 以字节为单位读取文件内容 
  21.      * @param filePath：需要读取的文件路径 
  22.      */  
  23.     public static void readFileByByte(String filePath) {  
  24.         File file = new File(filePath);  
  25.         // InputStream:此抽象类是表示字节输入流的所有类的超类。  
  26.         InputStream ins = null ;  
  27.         try{  
  28.             // FileInputStream:从文件系统中的某个文件中获得输入字节。  
  29.             ins = new FileInputStream(file);  
  30.             int temp ;  
  31.             // read():从输入流中读取数据的下一个字节。  
  32.             while((temp = ins.read())!=-1){  
  33.                 System.out.write(temp);  
  34.             }  
  35.         }catch(Exception e){  
  36.             e.getStackTrace();  
  37.         }finally{  
  38.             if (ins != null){  
  39.                 try{  
  40.                     ins.close();  
  41.                 }catch(IOException e){  
  42.                     e.getStackTrace();  
  43.                 }  
  44.             }  
  45.         }  
  46.     }  
  47.       
  48.     /** 
  49.      * 以字符为单位读取文件内容 
  50.      * @param filePath 
  51.      */  
  52.     public static void readFileByCharacter(String filePath){  
  53.         File file = new File(filePath);  
  54.         // FileReader:用来读取字符文件的便捷类。  
  55.         FileReader reader = null;  
  56.         try{  
  57.             reader = new FileReader(file);  
  58.             int temp ;  
  59.             while((temp = reader.read()) != -1){  
  60.                 if (((char) temp) != '\r') {  
  61.                     System.out.print((char) temp);  
  62.                 }  
  63.             }  
  64.         }catch(IOException e){  
  65.             e.getStackTrace();  
  66.         }finally{  
  67.             if (reader != null){  
  68.                 try {  
  69.                     reader.close();  
  70.                 } catch (IOException e) {  
  71.                     e.printStackTrace();  
  72.                 }  
  73.             }  
  74.         }  
  75.     }  
  76.       
  77.     /** 
  78.      * 以行为单位读取文件内容 
  79.      * @param filePath 
  80.      */  
  81.     public static void readFileByLine(String filePath){  
  82.         File file = new File(filePath);  
  83.         // BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。  
  84.         BufferedReader buf = null;  
  85.         try{  
  86.             // FileReader:用来读取字符文件的便捷类。  
  87.             buf = new BufferedReader(new FileReader(file));  
  88.             // buf = new BufferedReader(new InputStreamReader(new FileInputStream(file)));  
  89.             String temp = null ;  
  90.             while ((temp = buf.readLine()) != null ){  
  91.                 System.out.println(temp);  
  92.             }  
  93.         }catch(Exception e){  
  94.             e.getStackTrace();  
  95.         }finally{  
  96.             if(buf != null){  
  97.                 try{  
  98.                     buf.close();  
  99.                 } catch (IOException e) {  
  100.                     e.getStackTrace();  
  101.                 }  
  102.             }  
  103.         }  
  104.     }  
  105.   
  106.     public static void main(String args[]) {  
  107.         readFileByByte(FILE_PATH);  
  108.         readFileByCharacter(FILE_PATH);  
  109.         readFileByLine(FILE_PATH);  
  110.     }  
  111. }  
[java] view plain copy
  1. import java.io.BufferedReader;  
  2. import java.io.File;  
  3. import java.io.FileInputStream;  
  4. import java.io.FileReader;  
  5. import java.io.IOException;  
  6. import java.io.InputStream;  
  7. /** 
  8.  * <b>文件读取类</b><br /> 
  9.  * 1、按字节读取文件内容<br /> 
  10.  * 2、按字符读取文件内容<br /> 
  11.  * 3、按行读取文件内容<br /> 
  12.  * @author qin_xijuan 
  13.  * 
  14.  */  
  15. public class FileOperate {  
  16.       
  17.     private static final String FILE_PATH = "d:/work/the List of Beautiful Music.txt";  
  18.   
  19.     /** 
  20.      * 以字节为单位读取文件内容 
  21.      * @param filePath：需要读取的文件路径 
  22.      */  
  23.     public static void readFileByByte(String filePath) {  
  24.         File file = new File(filePath);  
  25.         // InputStream:此抽象类是表示字节输入流的所有类的超类。  
  26.         InputStream ins = null ;  
  27.         try{  
  28.             // FileInputStream:从文件系统中的某个文件中获得输入字节。  
  29.             ins = new FileInputStream(file);  
  30.             int temp ;  
  31.             // read():从输入流中读取数据的下一个字节。  
  32.             while((temp = ins.read())!=-1){  
  33.                 System.out.write(temp);  
  34.             }  
  35.         }catch(Exception e){  
  36.             e.getStackTrace();  
  37.         }finally{  
  38.             if (ins != null){  
  39.                 try{  
  40.                     ins.close();  
  41.                 }catch(IOException e){  
  42.                     e.getStackTrace();  
  43.                 }  
  44.             }  
  45.         }  
  46.     }  
  47.       
  48.     /** 
  49.      * 以字符为单位读取文件内容 
  50.      * @param filePath 
  51.      */  
  52.     public static void readFileByCharacter(String filePath){  
  53.         File file = new File(filePath);  
  54.         // FileReader:用来读取字符文件的便捷类。  
  55.         FileReader reader = null;  
  56.         try{  
  57.             reader = new FileReader(file);  
  58.             int temp ;  
  59.             while((temp = reader.read()) != -1){  
  60.                 if (((char) temp) != '\r') {  
  61.                     System.out.print((char) temp);  
  62.                 }  
  63.             }  
  64.         }catch(IOException e){  
  65.             e.getStackTrace();  
  66.         }finally{  
  67.             if (reader != null){  
  68.                 try {  
  69.                     reader.close();  
  70.                 } catch (IOException e) {  
  71.                     e.printStackTrace();  
  72.                 }  
  73.             }  
  74.         }  
  75.     }  
  76.       
  77.     /** 
  78.      * 以行为单位读取文件内容 
  79.      * @param filePath 
  80.      */  
  81.     public static void readFileByLine(String filePath){  
  82.         File file = new File(filePath);  
  83.         // BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。  
  84.         BufferedReader buf = null;  
  85.         try{  
  86.             // FileReader:用来读取字符文件的便捷类。  
  87.             buf = new BufferedReader(new FileReader(file));  
  88.             // buf = new BufferedReader(new InputStreamReader(new FileInputStream(file)));  
  89.             String temp = null ;  
  90.             while ((temp = buf.readLine()) != null ){  
  91.                 System.out.println(temp);  
  92.             }  
  93.         }catch(Exception e){  
  94.             e.getStackTrace();  
  95.         }finally{  
  96.             if(buf != null){  
  97.                 try{  
  98.                     buf.close();  
  99.                 } catch (IOException e) {  
  100.                     e.getStackTrace();  
  101.                 }  
  102.             }  
  103.         }  
  104.     }  
  105.   
  106.     public static void main(String args[]) {  
  107.         readFileByByte(FILE_PATH);  
  108.         readFileByCharacter(FILE_PATH);  
  109.         readFileByLine(FILE_PATH);  
  110.     }  
  111. }  
// ----------------------------------------------------------------- 分割线 -----------------------------------------------------------------------------

再经过两位同行的提点下，我对之前写的文件做了点修改，并通过读写一个1.2M的文本文件来测试各方法的性能。从多次测试结果来看，行读写却是是Java.nio更有效率。

经过修改之后的代码如下：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.waddell.basic;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.BufferedWriter;  
  5. import java.io.File;  
  6. import java.io.FileInputStream;  
  7. import java.io.FileOutputStream;  
  8. import java.io.FileReader;  
  9. import java.io.FileWriter;  
  10. import java.io.IOException;  
  11. import java.io.InputStream;  
  12. import java.io.OutputStream;  
  13. import java.nio.ByteBuffer;  
  14. import java.nio.channels.FileChannel;  
  15.   
  16. /** 
  17.  * <b>文件读取类</b><br /> 
  18.  * 1、按字节读取文件内容<br /> 
  19.  * 2、按字符读取文件内容<br /> 
  20.  * 3、按行读取文件内容<br /> 
  21.  *  
  22.  * @author qin_xijuan 
  23.  *  
  24.  */  
  25. public class FileOperate {  
  26.   
  27.     private static final String FILE_PATH = "d:/work/jipinwodi.txt";  
  28.   
  29.     /** 
  30.      * 以字节为单位读写文件内容 
  31.      *  
  32.      * @param filePath 
  33.      *            ：需要读取的文件路径 
  34.      */  
  35.     public static void readFileByByte(String filePath) {  
  36.         File file = new File(filePath);  
  37.         // InputStream:此抽象类是表示字节输入流的所有类的超类。  
  38.         InputStream ins = null;  
  39.         OutputStream outs = null;  
  40.         try {  
  41.             // FileInputStream:从文件系统中的某个文件中获得输入字节。  
  42.             ins = new FileInputStream(file);  
  43.             outs = new FileOutputStream("d:/work/readFileByByte.txt");  
  44.             int temp;  
  45.             // read():从输入流中读取数据的下一个字节。  
  46.             while ((temp = ins.read()) != -1) {  
  47.                 outs.write(temp);  
  48.             }  
  49.         } catch (Exception e) {  
  50.             e.getStackTrace();  
  51.         } finally {  
  52.             if (ins != null && outs != null) {  
  53.                 try {  
  54.                     outs.close();  
  55.                     ins.close();  
  56.                 } catch (IOException e) {  
  57.                     e.getStackTrace();  
  58.                 }  
  59.             }  
  60.         }  
  61.     }  
  62.   
  63.     /** 
  64.      * 以字符为单位读写文件内容 
  65.      *  
  66.      * @param filePath 
  67.      */  
  68.     public static void readFileByCharacter(String filePath) {  
  69.         File file = new File(filePath);  
  70.         // FileReader:用来读取字符文件的便捷类。  
  71.         FileReader reader = null;  
  72.         FileWriter writer = null;  
  73.         try {  
  74.             reader = new FileReader(file);  
  75.             writer = new FileWriter("d:/work/readFileByCharacter.txt");  
  76.             int temp;  
  77.             while ((temp = reader.read()) != -1) {  
  78.                 writer.write((char)temp);  
  79.             }  
  80.         } catch (IOException e) {  
  81.             e.getStackTrace();  
  82.         } finally {  
  83.             if (reader != null && writer != null) {  
  84.                 try {  
  85.                     reader.close();  
  86.                     writer.close();  
  87.                 } catch (IOException e) {  
  88.                     e.printStackTrace();  
  89.                 }  
  90.             }  
  91.         }  
  92.     }  
  93.   
  94.     /** 
  95.      * 以行为单位读写文件内容 
  96.      *  
  97.      * @param filePath 
  98.      */  
  99.     public static void readFileByLine(String filePath) {  
  100.         File file = new File(filePath);  
  101.         // BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。  
  102.         BufferedReader bufReader = null;  
  103.         BufferedWriter bufWriter = null;  
  104.         try {  
  105.             // FileReader:用来读取字符文件的便捷类。  
  106.             bufReader = new BufferedReader(new FileReader(file));  
  107.             bufWriter = new BufferedWriter(new FileWriter("d:/work/readFileByLine.txt"));  
  108.             // buf = new BufferedReader(new InputStreamReader(new  
  109.             // FileInputStream(file)));  
  110.             String temp = null;  
  111.             while ((temp = bufReader.readLine()) != null) {  
  112.                 bufWriter.write(temp+"\n");  
  113.             }  
  114.         } catch (Exception e) {  
  115.             e.getStackTrace();  
  116.         } finally {  
  117.             if (bufReader != null && bufWriter != null) {  
  118.                 try {  
  119.                     bufReader.close();  
  120.                     bufWriter.close();  
  121.                 } catch (IOException e) {  
  122.                     e.getStackTrace();  
  123.                 }  
  124.             }  
  125.         }  
  126.     }  
  127.   
  128.     /** 
  129.      * 使用Java.nio ByteBuffer字节将一个文件输出至另一文件 
  130.      *  
  131.      * @param filePath 
  132.      */  
  133.     public static void readFileByBybeBuffer(String filePath) {  
  134.         FileInputStream in = null;  
  135.         FileOutputStream out = null;  
  136.         try {  
  137.             // 获取源文件和目标文件的输入输出流    
  138.             in = new FileInputStream(filePath);  
  139.             out = new FileOutputStream("d:/work/readFileByBybeBuffer.txt");  
  140.             // 获取输入输出通道  
  141.             FileChannel fcIn = in.getChannel();  
  142.             FileChannel fcOut = out.getChannel();  
  143.             ByteBuffer buffer = ByteBuffer.allocate(1024);  
  144.             while (true) {  
  145.                 // clear方法重设缓冲区，使它可以接受读入的数据  
  146.                 buffer.clear();  
  147.                 // 从输入通道中将数据读到缓冲区  
  148.                 int r = fcIn.read(buffer);  
  149.                 if (r == -1) {  
  150.                     break;  
  151.                 }  
  152.                 // flip方法让缓冲区可以将新读入的数据写入另一个通道    
  153.                 buffer.flip();  
  154.                 fcOut.write(buffer);  
  155.             }  
  156.   
  157.         } catch (Exception e) {  
  158.             e.printStackTrace();  
  159.         } finally {  
  160.             if (in != null && out != null) {  
  161.                 try {  
  162.                     in.close();  
  163.                     out.close();  
  164.                 } catch (IOException e) {  
  165.                     e.printStackTrace();  
  166.                 }  
  167.             }  
  168.         }  
  169.     }  
  170.       
  171.     public static long getTime(){  
  172.         return System.currentTimeMillis();  
  173.     }  
  174.   
  175.     public static void main(String args[]) {  
  176.         long time1 = getTime() ;  
  177.         // readFileByByte(FILE_PATH);// 8734,8281,8000,7781,8047  
  178.         // readFileByCharacter(FILE_PATH);// 734, 437, 437, 438, 422  
  179.         // readFileByLine(FILE_PATH);// 110, 94,  94,  110, 93  
  180.         readFileByBybeBuffer(FILE_PATH);// 125, 78,  62,  78, 62  
  181.         long time2 = getTime() ;  
  182.         System.out.println(time2-time1);  
  183.     }  
  184. }  
[java] view plain copy
  1. package com.waddell.basic;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.BufferedWriter;  
  5. import java.io.File;  
  6. import java.io.FileInputStream;  
  7. import java.io.FileOutputStream;  
  8. import java.io.FileReader;  
  9. import java.io.FileWriter;  
  10. import java.io.IOException;  
  11. import java.io.InputStream;  
  12. import java.io.OutputStream;  
  13. import java.nio.ByteBuffer;  
  14. import java.nio.channels.FileChannel;  
  15.   
  16. /** 
  17.  * <b>文件读取类</b><br /> 
  18.  * 1、按字节读取文件内容<br /> 
  19.  * 2、按字符读取文件内容<br /> 
  20.  * 3、按行读取文件内容<br /> 
  21.  *  
  22.  * @author qin_xijuan 
  23.  *  
  24.  */  
  25. public class FileOperate {  
  26.   
  27.     private static final String FILE_PATH = "d:/work/jipinwodi.txt";  
  28.   
  29.     /** 
  30.      * 以字节为单位读写文件内容 
  31.      *  
  32.      * @param filePath 
  33.      *            ：需要读取的文件路径 
  34.      */  
  35.     public static void readFileByByte(String filePath) {  
  36.         File file = new File(filePath);  
  37.         // InputStream:此抽象类是表示字节输入流的所有类的超类。  
  38.         InputStream ins = null;  
  39.         OutputStream outs = null;  
  40.         try {  
  41.             // FileInputStream:从文件系统中的某个文件中获得输入字节。  
  42.             ins = new FileInputStream(file);  
  43.             outs = new FileOutputStream("d:/work/readFileByByte.txt");  
  44.             int temp;  
  45.             // read():从输入流中读取数据的下一个字节。  
  46.             while ((temp = ins.read()) != -1) {  
  47.                 outs.write(temp);  
  48.             }  
  49.         } catch (Exception e) {  
  50.             e.getStackTrace();  
  51.         } finally {  
  52.             if (ins != null && outs != null) {  
  53.                 try {  
  54.                     outs.close();  
  55.                     ins.close();  
  56.                 } catch (IOException e) {  
  57.                     e.getStackTrace();  
  58.                 }  
  59.             }  
  60.         }  
  61.     }  
  62.   
  63.     /** 
  64.      * 以字符为单位读写文件内容 
  65.      *  
  66.      * @param filePath 
  67.      */  
  68.     public static void readFileByCharacter(String filePath) {  
  69.         File file = new File(filePath);  
  70.         // FileReader:用来读取字符文件的便捷类。  
  71.         FileReader reader = null;  
  72.         FileWriter writer = null;  
  73.         try {  
  74.             reader = new FileReader(file);  
  75.             writer = new FileWriter("d:/work/readFileByCharacter.txt");  
  76.             int temp;  
  77.             while ((temp = reader.read()) != -1) {  
  78.                 writer.write((char)temp);  
  79.             }  
  80.         } catch (IOException e) {  
  81.             e.getStackTrace();  
  82.         } finally {  
  83.             if (reader != null && writer != null) {  
  84.                 try {  
  85.                     reader.close();  
  86.                     writer.close();  
  87.                 } catch (IOException e) {  
  88.                     e.printStackTrace();  
  89.                 }  
  90.             }  
  91.         }  
  92.     }  
  93.   
  94.     /** 
  95.      * 以行为单位读写文件内容 
  96.      *  
  97.      * @param filePath 
  98.      */  
  99.     public static void readFileByLine(String filePath) {  
  100.         File file = new File(filePath);  
  101.         // BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。  
  102.         BufferedReader bufReader = null;  
  103.         BufferedWriter bufWriter = null;  
  104.         try {  
  105.             // FileReader:用来读取字符文件的便捷类。  
  106.             bufReader = new BufferedReader(new FileReader(file));  
  107.             bufWriter = new BufferedWriter(new FileWriter("d:/work/readFileByLine.txt"));  
  108.             // buf = new BufferedReader(new InputStreamReader(new  
  109.             // FileInputStream(file)));  
  110.             String temp = null;  
  111.             while ((temp = bufReader.readLine()) != null) {  
  112.                 bufWriter.write(temp+"\n");  
  113.             }  
  114.         } catch (Exception e) {  
  115.             e.getStackTrace();  
  116.         } finally {  
  117.             if (bufReader != null && bufWriter != null) {  
  118.                 try {  
  119.                     bufReader.close();  
  120.                     bufWriter.close();  
  121.                 } catch (IOException e) {  
  122.                     e.getStackTrace();  
  123.                 }  
  124.             }  
  125.         }  
  126.     }  
  127.   
  128.     /** 
  129.      * 使用Java.nio ByteBuffer字节将一个文件输出至另一文件 
  130.      *  
  131.      * @param filePath 
  132.      */  
  133.     public static void readFileByBybeBuffer(String filePath) {  
  134.         FileInputStream in = null;  
  135.         FileOutputStream out = null;  
  136.         try {  
  137.             // 获取源文件和目标文件的输入输出流    
  138.             in = new FileInputStream(filePath);  
  139.             out = new FileOutputStream("d:/work/readFileByBybeBuffer.txt");  
  140.             // 获取输入输出通道  
  141.             FileChannel fcIn = in.getChannel();  
  142.             FileChannel fcOut = out.getChannel();  
  143.             ByteBuffer buffer = ByteBuffer.allocate(1024);  
  144.             while (true) {  
  145.                 // clear方法重设缓冲区，使它可以接受读入的数据  
  146.                 buffer.clear();  
  147.                 // 从输入通道中将数据读到缓冲区  
  148.                 int r = fcIn.read(buffer);  
  149.                 if (r == -1) {  
  150.                     break;  
  151.                 }  
  152.                 // flip方法让缓冲区可以将新读入的数据写入另一个通道    
  153.                 buffer.flip();  
  154.                 fcOut.write(buffer);  
  155.             }  
  156.   
  157.         } catch (Exception e) {  
  158.             e.printStackTrace();  
  159.         } finally {  
  160.             if (in != null && out != null) {  
  161.                 try {  
  162.                     in.close();  
  163.                     out.close();  
  164.                 } catch (IOException e) {  
  165.                     e.printStackTrace();  
  166.                 }  
  167.             }  
  168.         }  
  169.     }  
  170.       
  171.     public static long getTime(){  
  172.         return System.currentTimeMillis();  
  173.     }  
  174.   
  175.     public static void main(String args[]) {  
  176.         long time1 = getTime() ;  
  177.         // readFileByByte(FILE_PATH);// 8734,8281,8000,7781,8047  
  178.         // readFileByCharacter(FILE_PATH);// 734, 437, 437, 438, 422  
  179.         // readFileByLine(FILE_PATH);// 110, 94,  94,  110, 93  
  180.         readFileByBybeBuffer(FILE_PATH);// 125, 78,  62,  78, 62  
  181.         long time2 = getTime() ;  
  182.         System.out.println(time2-time1);  
  183.     }  
  184. }  

在main方法中，调用各方法之后，有五组数据，分辨是我5次读写文件测试出来的时间（毫秒）。

关于Java.nio 请参考：http://www.iteye.com/topic/834447

付我个人测试：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1.     public static void main(String args[]) {  
  2.         long time1 = getTime() ;  
  3. //         readFileByByte(FILE_PATH);     //2338,2286  
  4. //         readFileByCharacter(FILE_PATH);//160,162,158  
  5. //         readFileByLine(FILE_PATH);     //46,51,57  
  6. //        readFileByBybeBuffer(FILE_PATH);//19,18,17  
  7. //        readFileByBybeBuffer(FILE_PATH);//2048: 11,13  
  8. //        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,711k: 6,6  
  9. //        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,1422k: 7  
  10. //        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,9951k: 49,48  
  11. //        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,711k: 7,7  
  12. //        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,1422k: 7,8  
  13. //        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,9951k: 48,49  
  14. //        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,711k: 21,13,17  
  15. //        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,1422k: 16,17,14,15  
  16. //        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,9951k:64,60  
  17.           
  18.         long time2 = getTime() ;  
  19.         System.out.println(time2-time1);  
  20.     }  
[java] view plain copy
  1.     public static void main(String args[]) {  
  2.         long time1 = getTime() ;  
  3. //         readFileByByte(FILE_PATH);     //2338,2286  
  4. //         readFileByCharacter(FILE_PATH);//160,162,158  
  5. //         readFileByLine(FILE_PATH);     //46,51,57  
  6. //        readFileByBybeBuffer(FILE_PATH);//19,18,17  
  7. //        readFileByBybeBuffer(FILE_PATH);//2048: 11,13  
  8. //        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,711k: 6,6  
  9. //        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,1422k: 7  
  10. //        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,9951k: 49,48  
  11. //        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,711k: 7,7  
  12. //        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,1422k: 7,8  
  13. //        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,9951k: 48,49  
  14. //        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,711k: 21,13,17  
  15. //        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,1422k: 16,17,14,15  
  16. //        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,9951k:64,60  
  17.           
  18.         long time2 = getTime() ;  
  19.         System.out.println(time2-time1);  
  20.     }  


转自：http://www.cnblogs.com/waddell/archive/2013/01/24/2874104.html
阅读全文
0 0
绣春刀2影评知乎 绣春刀2影评知乎
原创粉丝点击
热门IT博客
java初级工程师简历java初级工程师简历
万维软件豪华版万维软件豪华版
雅思听力精听方法 知乎
羽绒被牌子 知乎
绵阳广播电视网络
淘宝开店 旺旺名字
进销存软件排行
渡边直美 知乎
java责任链模式
黄鹤tv武汉网络电视
mysql select offset
php 刷新重复提交表单
淘宝的寄修手机可靠吗
神话 知乎
linux history 清除
冰川网络的游戏怎么样
U盘品牌 知乎
淘宝怎么进自己的店铺
斗鱼主播唱歌软件
对电影台词软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 宿管秦大爷故事全集 宿管部面试问题及答案 宿管部部长竞选稿 噩梦时代宿管变异 宿管部工作总结 小雪与宿管大爷全文 宿管会申请书 2018竞选宿管部干事3分钟演讲 宿管会面试自我介绍 学生会宿管部演讲稿 急聘宿管老师2人 宿管部面试常问问题 我和宿管王阿姨那段故事 宿管部面试 宿管部个人工作总结 与宿管王阿姨完整篇 川影追责宿管员 宿管部的工作总结1000字 宿管会工作总结 宿管员的职责 学校宿管招聘 淄博职业学院宿管部 宿舍 宿舍床尺寸 宿舍群名 宿舍偷怕 宿舍姐妹 大学宿舍 宿舍h 宿舍图片 宿舍拼音 宿舍英文 宿舍照片 学校宿舍 大学生宿舍 换宿舍 男生宿舍可以多欢乐 我在宿舍狂抽表妹txt 校园宿舍一龙战双胞胎 402宿舍五姐妹 宿舍的惩罚play

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里