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

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

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

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

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

1、字节读写(InputStream/OutputStream)

2、字符读取(FileReader/FileWriter)

3、行读取(BufferedReader/BufferedWriter)

代码(以读取为例):

[java] view plain copy print ?
  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 plain copy print ?
  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 plain copy print ?
  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

你可能感兴趣的:(java读写文件,IONIO读写文件比较,java读写文件性能比较,IONIO的使用,读取文件性能测试)