Java之IO流学习总结 (转载备忘)

转载自：http://88889999.iteye.com/blog/1617423

 

因近段时间项目频繁使用了IO流，之前我没有系统的学习这方面的知识，在使用时感觉有点迷糊，IO流是Java核心技术的一个高级应用，使用非常频繁，遂在网上找了这方面的资料系统的学习了一下，现把学习成果贴与大家分享，万物皆有裂痕，请各位大神多提出问题一起探讨，共同进步。先来看一个IO流对象继承关系图，现在还不会UML，画的图没有那么专业，就将就着看吧，等我学好了UML再改回来：

其他常用与流有关的对象：

 

 

一、什么是流？

流就是字节序列的抽象概念，能被连续读取数据的数据源和能被连续写入数据的接收端就是流，流机制是 Java及 C++中的一个重要机制，通过流我们可以自由地控制文件、内存、 IO设备等数据的流向。而 IO流就是用于处理设备上的数据，如：硬盘、内存、键盘录入等。 IO流根据处理类型的不同可分为字节流和字符流，根据流向的不同可分为输入流和输出流。

 

二、字节流和字符流的区别：
字符流，因为文件编码的不同，就有了对字符进行高效操作的字符流对象，它的原理就是基于字节流读取字节时去查了指定的码表。它和字节流的区别有两点：1.在读取数据的时候，字节流读到一个字节就返回一个字节，字符流使用了字节流读到一个或多个字节（一个中文对应的字节数是两个，在UTF-8码表中是3个字节）时，先去查指定的编码表，再将查到的字符返回；2.字节流可以处理所有类型的数据，如jpg、avi、mp3、wav等等，而字符流只能处理字符数据。所以可以根据处理的文件不同考虑使用字节流还是字符流，如果是纯文本数据可以优先考虑字符流，否则使用字节流。

三、IO体系，所具备的基本功能就是读和写：
1.字符流

|-- Reader（读）

|-- Writer（写）

Reader

|--InputStreamReader

|--FileReader：用于处理文件的字符读取流对象

Writer

|--OutputStreamWriter

|--FileWriter：用于处理文件的字符写入流对象

其实很容易就可以看出来，IO体系中的子类名后缀绝大部分是父类名称，而前缀则是体现子类特有功能的名称。

Reader中常见的方法：

|--int read()

读取一个字符，并返回读到的这个字符，读到流的末尾则返回-1。

|--int read(char[])

将读到的字符存入指定的数组中，返回的是读到的字符个数，

读到流的末尾则返回-1。

|--close()

读取字符其实用的是window系统的功能，就希望使用完毕后，

进行资源的释放。

FileReader除了自己的构造函数外没有特有的方法：

|--用于读取文本文件的流对象。

|--用于关联文本文件。

|--构造函数FileReader(String fileName)

在读取流对象初始化时，必须要指定一个被读取的文件，

如果该文件不存在则会发生FileNotFoundException异常。

Writer中常见的方法：

|--write()

将一个字符写入到流中。

|--write(char[])

将一个字符数组写入到流中。

|--writer(String)

将一个字符写入到流中。

|--flush()

刷新流，将流中的数据刷新到目的地中，流还存在。

|--close()

关闭资源，在关闭钱会先调用flush()， 刷新流中的数据到目的地。

FileWriter，除了自己的构造函数外没有特有的方法：

|--该类的特点

|--用于处理文本文件

|--没有默认的编码表

|--有临时缓冲

|--构造函数，在写入流对象初始化时，必须要有一个存储数据的目的地。

|--FileWriter(String fileName)，该构造器是干什么用的呢？

|--调用系统资源

|--在指定位置创建一个文件，如果该文件已经存在则被覆盖。

|--FileWriter(String filename,Boolean append)，这构造器的作用是？

当传入的boolean类型的值为true时，会在指定文件末尾处进行数据的续写。

 

清单1，将文本数据保存到文件中代码   

1. private static void test1(){  
2.     FileWriter fw=null;  
3.     try {  
4.         //初始化FileWriter对象，指定文件名已经存储路径  
5.         fw=new FileWriter("D:/test.txt");  
6.         fw.write("将字符串写入流");  
7.         //将流中的数据刷新到目的地，流还在  
8.         fw.flush();  
9.         fw.write("将字符串写入流");  
10.     } catch (IOException e) {  
11.         e.printStackTrace();  
12.     }finally{  
13.         if(fw!=null){  
14.             try {  
15.                 fw.close();  
16.             } catch (IOException e1) {  
17.                 e1.printStackTrace();  
18.             }  
19.               
20.         }  
21.     }  
22. }  

 

 

 

清单2，读取一个已有文本文件，并将文本内容打印出来代码   

1. private static void test2(){  
2.     FileReader fr=null;  
3.     try {  
4.         //初始化FileReader对象，指定文件路径  
5.         fr=new FileReader("D:/test.txt");  
6.         int ch=0;  
7.         while((ch=fr.read())!=-1){  
8.             //每次读取一个字符，直到读到末尾-1为止  
9.             System.out.println((char)ch);  
10.         }  
11.     } catch (IOException e) {  
12.         e.printStackTrace();  
13.     }finally{  
14.         if(fr!=null){  
15.             try {  
16.                 fr.close();  
17.             } catch (IOException e1) {  
18.                 e1.printStackTrace();  
19.             }  
20.               
21.         }  
22.     }  
23. }  

这样每读到一个字符就打印出来，效率很不高，能不能按指定大小读取完后再打印出来呢？答案是当然可以的。

 

清单3，读取一个已有文本文件，读完1kb再将其读到的内容打印出来代码   

1. private static void test3(){  
2.     FileReader fr=null;  
3.     try {  
4.         //初始化FileReader对象，指定文件路径  
5.         fr=new FileReader("D:/test.txt");  
6.         char[] buf=new char[1024];  
7.         int len=0;  
8.         while((len=fr.read(buf))!=-1){  
9.             //每次读取1kb大小的字符，直到读到末尾-1为止  
10.             System.out.println(new String(buf,0,len));  
11.         }  
12.     } catch (IOException e) {  
13.         e.printStackTrace();  
14.     }finally{  
15.         if(fr!=null){  
16.             try {  
17.                 fr.close();  
18.             } catch (IOException e1) {  
19.                 e1.printStackTrace();  
20.             }  
21.               
22.         }  
23.     }  
24. }  

 

 

字符流的缓冲区：

|--缓冲区的出现提高了对流的操作效率。

原理：其实就是将数组进行封装。

|--对应的对象

|--BufferedWriter

特有方法newLine()，跨平台的换行符。

|--BufferedReader

特有方法readLine()，一次读一行，到行标记时，将行标记

之前的字符数据作为字符串返回，读到末尾返回null。

|--说明

在使用缓冲区对象时，要明确，缓冲的存在是为了增强流

的功能而存在，所以在建立缓冲区对象时，要先有流对象

存在。其实缓冲区内部就是在使用流对象的方法，只不过

加入了数组对数据进行了临时存储，为了提高操作数据的

效率。

|--代码上的体现

|--写入缓冲区对象

根据前面所说的建立缓冲区时要先有流对象，并将其作为参数传递给缓冲区的构造函数

BufferedWriter bufw=new BufferedWriter(new FileWriter(“test.txt”));

bufw.write(“将数据写入缓冲区”);

bufw.flush();//将缓冲区的数据刷新到目的地

bufw.close();//其实关闭的是被包装在内部的流对象

|--读取缓冲区对象

BufferedReader bufr=new BufferedReader(new FileReader(“test.txt”));

String line=null;

while((line=bufr.readLine())!=null){

//每次读取一行，取出的数据不包含回车符

system.out.println(line);

}

bufr.close();

 

 

清单4，使用缓冲区对文本文件进行拷贝代码   

1. private static void test4(){  
2.     BufferedReader bufr=null;  
3.     BufferedWriter bufw=null;  
4.     try {  
5.         /*  
6.          * 缓冲对象依赖于流对象，所以要先创建流对象  
7.          */  
8.         bufr=new BufferedReader(new FileReader("D:/a.txt"));  
9.         bufw=new BufferedWriter(new FileWriter("D:/b.txt"));  
10.         String line=null;  
11.         while((line=bufr.readLine())!=null){  
12.             bufw.write(line);//每次将一行写入缓冲区  
13.             bufw.flush();//刷新到目的地  
14.         }  
15.     } catch (IOException e) {  
16.         e.printStackTrace();  
17.     }finally{  
18.         try {  
19.             if(bufw!=null){  
20.                 bufw.close();  
21.             }  
22.             if(bufr!=null){  
23.                 bufr.close();  
24.             }  
25.         } catch (IOException e1) {  
26.             e1.printStackTrace();  
27.         }  
28.     }  
29. }  

 仔细看可以发现，程序里面的FileReader对象和FileWriter对象直接new出来且没有调用close()，因为缓冲对象调用了这两个方法，前面说了，缓冲对象调用的flush()和close()其实就是关闭被包装在其内部的流对象。关闭流的先后顺序也要注意，如果流之间有依赖关系，则被依赖的流要后关闭。readLine()方法原理：其实缓冲区中的该方法，用的还是与缓冲区关联的流对象的read方法，只不过，每一次读到一个字符先不进行具体操作，先进行临时存储，当读到回车标记时，将临时容器中存储的数据一次性返回。我们可以根据这个原理来自己编写一个缓冲区对象。

 

清单5，编写一个自己的bufferedreader代码   

1. /**  
2.  * @fileName MyBufferedReader.java  
3.  * @description 根据readLine()原理  
4.  *              写一个自己的缓冲对象  
5.  * @date 2012-7-25  
6.  * @time 17:45  
7.  * @author wst  
8.  */  
9. public class MyBufferedReader {  
10.     private Reader reader;  
11.     public MyBufferedReader(Reader reader){  
12.         this.reader=reader;  
13.     }  
14.       
15.     public String readLine() throws IOException{  
16.         StringBuilder sb=new StringBuilder();  
17.         int ch=0;  
18.         while((ch=reader.read())!=-1){  
19.             if(ch=='\r'){//空格则继续  
20.                 continue;  
21.             }else if(ch=='\n'){//每次返回一行  
22.                 return sb.toString();  
23.             }else{  
24.                 sb.append((char)ch);  
25.             }  
26.         }  
27.         return sb.toString();  
28.     }  
29.       
30.       
31.     public void close() throws IOException{  
32.         //缓冲对象的关闭方法其实就是调用流本身的close()  
33.         reader.close();  
34.     }  
35. }  

 测试时把清单4的BufferedReader对象替换成MyBufferedReader对象即可。

 

清单6，测试mybufferedreader代码   

1. private static void test4(){  
2.     MyBufferedReader bufr=null;  
3.     BufferedWriter bufw=null;  
4.     try {  
5.         /*  
6.          * 缓冲对象依赖于流对象，所以要先创建流对象  
7.          */  
8.         bufr=new MyBufferedReader(new FileReader("D:/a.txt"));  
9.         bufw=new BufferedWriter(new FileWriter("D:/b.txt"));  
10.         String line=null;  
11.         while((line=bufr.readLine())!=null){  
12.             bufw.write(line);//每次将一行写入缓冲区  
13.             bufw.flush();//刷新到目的地  
14.         }  
15.     } catch (IOException e) {  
16.         e.printStackTrace();  
17.     }finally{  
18.         try {  
19.             if(bufw!=null){  
20.                 bufw.close();  
21.             }  
22.             if(bufr!=null){  
23.                 bufr.close();  
24.             }  
25.         } catch (IOException e1) {  
26.             e1.printStackTrace();  
27.         }  
28.     }  
29. }  

 其实我们自己写的这个缓存对象就是对Reader对象进行了功能的增强，Reader对象每次只能返回一个字符，而增强了功能之后该类就可以每次返回一行字符，也就是设计模式中所说的装饰模式。

 

2.字节流

|-- InputStream（读）

|-- OutputStream（写）

由于字节是二进制数据，所以字节流可以操作任何类型的数据，值得注意的是字符流使用的是字符数组char[]而字节流使用的是字节数组byte[]。下面来看一个字节流读写文件的简单例子。

清单7，使用字节流读写文本文件代码   

1. private static void test5(){  
2.     FileOutputStream fos=null;  
3.     try{  
4.         fos=new FileOutputStream("D:/test.txt");  
5.         fos.write(0010);//写入二进制数据  
6.         fos.flush();  
7.     }catch(IOException e){  
8.           
9.     }finally{  
10.         try{  
11.             fos.close();  
12.         }catch(IOException ex){  
13.               
14.         }  
15.     }  
16.     FileInputStream fis=null;  
17.     try{  
18.         fis=new FileInputStream("D:/test.txt");  
19.         //fis.available()是获取关联文件的字节数，即test.txt的字节数  
20.         //这样创建的数组大小就和文件大小刚好相等  
21.         //这样做的缺点就是文件过大时，可能超出jvm的内存空间，从而造成内存溢出  
22.         byte[] buf=new byte[fis.available()];  
23.         fis.read(buf);  
24.         System.out.println(new String(buf));  
25.     }catch(IOException e){  
26.           
27.     }finally{  
28.         try{  
29.             fos.close();  
30.         }catch(IOException ex){  
31.               
32.         }  
33.     }  
34. }  

 

 

清单8，使用缓冲区对一张图片进行复制代码   

1. private static void test6(){  
2.     BufferedOutputStream bos=null;  
3.     BufferedInputStream bis=null;  
4.     try{  
5.         //前面已经说过了，缓冲对象是根据具体的流对象创建的，所以必须要有流对象  
6.         bis=new BufferedInputStream(new FileInputStream("E:\\images\\wo\\1.jpg"));  
7.         //写入目标地址  
8.         bos=new BufferedOutputStream(new FileOutputStream("E:\\test.jpg"));  
9.         byte[] buf=new byte[1024];  
10.         while((bis.read(buf))!=-1){  
11.             bos.write(buf);  
12.         }  
13.         bos.flush();  
14.     }catch(IOException e){  
15.         e.toString();  
16.     }finally{  
17.         try{  
18.             if(bos!=null){  
19.                 bos.close();  
20.             }  
21.             if(bis!=null){  
22.                 bis.close();  
23.             }  
24.         }catch(IOException ex){  
25.             ex.toString();  
26.         }  
27.     }  
28. }  

 

 

 

3.转换流

    特点

        |--是字节流和字符流之间的桥梁

       |--该流对象可以对读取到的字节数据进行指定编码表的编码转换

    何时使用

       |--当字节和字符之间有转换动作时

       |--流操作的数据需要进行编码表的指定时

    具体对象体现

       |--InputStreamReader：字节到字符的桥梁

       |--OutputStreamWriter：字符到字节的桥梁

    说明

       这两个流对象是字符流体系中的成员，它们有转换的作用，而本身又是字符流，

所以在new的时候需要传入字节流对象。

    构造函数

       |--InputStreamReader(InputStream)

           通过该构造函数初始化，使用的是系统默认的编码表GBK。

       |--InputStreamReader(InputStream,String charset)

           通过该构造函数初始化，可以通过charset参数指定编码。

       |--OutputStreamWriter(OutputStream)

           使用的是系统默认的编码表GBK。

       |--OutputStreamWriter(OutputSream,String charset)

           通过该构造函数初始化，可以通过参数charset指定编码。

    操作文件的字符流对象是转换流的子类

       |--Reader

           |--InputStreamReader（转换流）

              |--FileReader（文件字符流）

       |--Writer

           |--OutputStreamWriter（转换流）

              |--FileWriter（文件字符流）

    说明

       转换流中的read方法，已经融入了编码表，在底层调用字节流的

       read方法时将获取的一个或者多个字节数据进行临时存储，并去

       查指定的编码表，如果编码没有指定，则使用默认编码表。

       既然转换流已经完成了编码转换的动作，对于直接操作的文本文
       件的FileReader而言，就不用再重新定义了，只要继承该转换

       流，获取其方法，就可以直接操作文本文件中的字符数据了。

    注意

       在使用FileReader操作文本数据时，该对象使用的是默认的编码表，

       如果要使用指定的编码表，必须使用转换流。

    代码体现

        FileReader fr=new FileReader(“test.txt”);
        InputStreamReader isr=new InputStreamReader(new

FileInputStreamReader(“test.txt”));

这两句代码意义相同，操作test.txt中的数据都是使用了系统默认

的编码GBK。因为我们系统默认使用的编码表是GBK，如果test.txt中

的数据是通过UTF-8形式编码的，那么在读取的时候就需要指定编码表，

因此转换流必须使用InputStreamReader isr=new

InputStreamReader(new FileInputStream(“a.txt”),”UTF-8”);

 

四、流操作的基本规律

|--明确数据源和数据汇（数据目的）

其实是为了明确是输入流还是输出流

|--明确操作的数据是否是纯文本数据

|--说明

数据源

     键盘System.in、硬盘、File开头的流对象、内存（数组）。

数据汇

     控制台System.out、硬盘、File开头的流对象、内存（数组）。

|--需求

将键盘录入的数据存储到一个文件中和打印到控制台

     |--数据源System.in

        既然是源，使用的就是输入流，可用的体系有InputStream

        、Reader。因为键盘录入进来的一定是纯文本数据，所以

        可以使用专门操作字符数据的Reader。而System.in对应

        的流是字节读取流，所以要将其进行转换，将字节转换成字

符即可，所以要使用Reader体系中的InputStreamReader，

如果要提高效率，就使用BufferedReader，代码如：

BufferedReader bur=new BufferedReader(new

InputStreamReader(Sysem.in));

           |--数据汇：一个文件、硬盘

              数据汇一定是输出流，可以用的体系有OutputStream、

              Writer。往文件中存储的都是文本数据，那么可以使用字符

              流较为方便Writer。因为操作的是一个文件，所以使用Writer

              中的FileWriter，同理，要提高效率就要使用BufferedWriter。

              代码如：BufferedWriter bufr=new BufferedWriter(new

FileWriter(“test.txt”));

 

 

清单9，将键盘录入的数据存储到一个文件中和打印到控制台代码   

1. private static void test7(){  
2.     BufferedReader bur=null;  
3.     OutputStreamWriter osw=null;  
4.     BufferedWriter bw=null;  
5.     try{  
6.         //数据源  
7.         bur=new BufferedReader(new InputStreamReader(System.in));  
8.         //数据汇  
9.         osw=new OutputStreamWriter(System.out);  
10.         //数据汇，因为数据源用的是系统默认编码，所以这里可以直接使用FileWriter  
11.         //否则必须使用OutputStreamWriter转换流  
12.         bw=new BufferedWriter(new FileWriter("D:\\test_target.txt"));  
13.         String line=null;  
14.         while((line=bur.readLine())!=null){  
15.             osw.write(line);  
16.             osw.flush();//刷新到控制台  
17.             bw.write(line);  
18.             bw.flush();//刷新到文本文件  
19.         }     
20.     }catch(IOException e){  
21.         e.toString();  
22.     }finally{  
23.         try{  
24.             if(osw!=null){  
25.                 osw.close();  
26.             }  
27.             if(bur!=null){  
28.                 bur.close();  
29.             }  
30.             if(bw!=null){  
31.                 bw.close();  
32.             }  
33.         }catch(IOException ex){  
34.             ex.toString();  
35.         }  
36.     }  
37. }  

 清单9是按照默认编码表写入文本文件的，那么如何按照指定编码表写入文件呢？其实也很简单，将清单9的代码稍微改一下就可以了。

 

清单10代码   

1. private static void test8(){  
2.     BufferedReader bur=null;  
3.     BufferedWriter bw=null;  
4.     try{  
5.         //数据源  
6.         bur=new BufferedReader(new InputStreamReader(System.in));  
7.         //数据汇，按照指定编码格式存储到文本文件  
8.         bw=new BufferedWriter(new OutputStreamWriter(new   
9.         FileOutputStream("D:\\test_target.txt"),"UTF-8"));  
10.         String line=null;  
11.         while((line=bur.readLine())!=null){  
12.             bw.write(line);  
13.             bw.flush();//刷新到文本文件  
14.         }     
15.     }catch(IOException e){  
16.         e.toString();  
17.     }finally{  
18.         try{  
19.             if(bur!=null){  
20.                 bur.close();  
21.             }  
22.             if(bw!=null){  
23.                 bw.close();  
24.             }  
25.         }catch(IOException ex){  
26.             ex.toString();  
27.         }  
28.     }  
29. }  

 

 

既然写入文件时指定了编码，那么在读取的时候就必须指定该编码才能正确显示。

 

清单11,读取指定编码表的文件代码   

1. private static void test9() {  
2.     BufferedReader bur = null;  
3.     try {  
4.         // 注意，这里读取的是清单8写入的文件，  
5.         // 清单10用UTF-8编码格式写入，  
6.         // 所以在构造InputStreamReader时必须指定UTF-8编码  
7.         bur = new BufferedReader(new InputStreamReader(  
8. new FileInputStream("D:\\test_target.txt"), "UTF-8"));  
9.         String line = null;  
10.         while ((line = bur.readLine()) != null) {  
11.             System.out.println(line);  
12.         }  
13.     } catch (IOException e) {  
14.         e.toString();  
15.     } finally {  
16.         try {  
17.             if (bur != null) {  
18.                 bur.close();  
19.             }  
20.         } catch (IOException ex) {  
21.             ex.toString();  
22.         }  
23.     }  
24. }  

 

 

写入和读取都做了，现在还差个复制操作，其实复制文件也很简单，先读取文件，再将读取到的数据写入文件，不同的是，在读取和写入时我们可以指定编码表。

 

清单12代码   

1. private static void test11() {  
2.     BufferedReader bur = null;  
3.     BufferedWriter buw = null;  
4.     try {  
5.         bur = new BufferedReader(new InputStreamReader(  
6. new FileInputStream("D:\\test_target.txt"), "UTF-8"));  
7.         buw = new BufferedWriter(new OutputStreamWriter(  
8.         new FileOutputStream("D:\\test_target1.txt"),"UTF-8"));  
9.         String line = null;  
10.         while ((line = bur.readLine()) != null) {  
11.             buw.write(line);  
12.             buw.flush();// 刷新到文本文件  
13.         }  
14.     } catch (IOException e) {  
15.         e.toString();  
16.     } finally {  
17.         try {  
18.             if (buw != null) {  
19.                 buw.close();  
20.             }  
21.             if (bur != null) {  
22.                 bur.close();  
23.             }  
24.         } catch (IOException ex) {  
25.             ex.toString();  
26.         }  
27.     }  
28. }