黑马程序员——IO流

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ -------------------------

1、IO流

         IO流，用来处理设备间的数据传输，Java中对数据的操作是通过流的方式。

         java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流。

            

2、字符流Writer/Reader

      Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

（1）字符输出流 Writer

        Writer写入字符流的抽象类。子类必须实现的方法仅有write(char[], int, int)、flush() 和 close()。

  [1]熟悉Writer中write，flush，close方法

[java] view plaincopyprint?

1. public class FileWriterDemo {  
2.   
3.     public static void main(String[] args) throws IOException {  
4.   
5.         // 创建一个FileWriter对象   
6.         FileWriter fw = new FileWriter("FileWriterDemo.txt");  
7.         // 调用write方法,将字符串写到流中   
8.         fw.write("hello wrold!");  
9.   
10.     }  
11. }  

public class FileWriterDemo {public static void main(String[] args) throws IOException {// 创建一个FileWriter对象FileWriter fw = new FileWriter("FileWriterDemo.txt");// 调用write方法,将字符串写到流中fw.write("hello wrold!");}}

当执行上述代码时，FileWriterDemo.txt文件上并没有任何字符。原因：FileWriter对象其实先把数据写入到了缓冲区中，所以需要使用flush()方法，或

者close()方法，把缓冲区的数据刷新到目的地上。

[java] view plaincopyprint?

1. // 刷新流对象中的缓冲中的数据   
2. // fw.flush();   
3. // 关闭流资源,关闭前会刷新一次内部的缓冲数据   
4. fw.close();  

  // 刷新流对象中的缓冲中的数据// fw.flush();// 关闭流资源,关闭前会刷新一次内部的缓冲数据fw.close();

      flush()方法与close()方法区别：flush刷新后，流还可以使用；close刷新后，流关闭。

   FileWriter还有一个特点：创建一个FileWriter对象,该类对象一被初始化就必须要明确被操作的文件；而且该文件会被创建到指定目录下,如

果该目录下已有同名文件,将被覆盖.所以向一个已经数据的文件添加数据又该如何？如果按照之前的方法，该文件将会被覆盖。

   FileWriter(File file, boolean append)提供这个方法，当第二个参数为true，则将字节写入文件末尾处，而不是写入文件开始处。




（1）字符输入流 Reader


      用于读取字符流的抽象类。子类必须实现的方法只有read(char[], int, int) 和 close()。


   读取的字符输入流FileReader：两种方法读取文本

       实例代码：

[java] view plaincopyprint?

1. /* 
2.  * 第一种方式:通过每次取出一个字符的方式读取  
3.  * read()返回的字符的10进制数字.  
4.  */  
5. public class FileReaderDemo {  
6.   
7.     public static void main(String[] args) {  
8.         FileReader fr = null;  
9.         try {  
10.             // 创建一个文件读取流对象,和指定名称的文件相关联.   
11.             fr = new FileReader("FileWriterDemo.txt");  
12.             int ch = -1;  
13.             while ((ch = fr.read()) != -1) {  
14.                 System.out.println((char) ch);  
15.             }  
16.         } catch (IOException e) {  
17.             System.out.println(e.toString());  
18.         } finally {  
19.             try {  
20.                 if (fr != null)  
21.                     fr.close();  
22.             } catch (IOException e) {  
23.                 e.printStackTrace();  
24.             }  
25.         }  
26.     }  
27. }  

/* * 第一种方式:通过每次取出一个字符的方式读取  * read()返回的字符的10进制数字.  */public class FileReaderDemo {public static void main(String[] args) {FileReader fr = null;try {// 创建一个文件读取流对象,和指定名称的文件相关联.fr = new FileReader("FileWriterDemo.txt");int ch = -1;while ((ch = fr.read()) != -1) {System.out.println((char) ch);}} catch (IOException e) {System.out.println(e.toString());} finally {try {if (fr != null)fr.close();} catch (IOException e) {e.printStackTrace();}}}}

[java] view plaincopyprint?

1. // 第二种方式:通过字符数组进行读取.   
2.         fr = new FileReader("FileWriterDemo.txt");  
3.         // 定义一个字符数组,用于存储读取到的字符  
4.         // 该read(char[])返回的是读到的字符个数   
5.         char[] ch = new char[1024];  
6.         int num = 0;  
7.         while ((num = fr.read(ch)) != -1) {  
8.             System.out.println(new String(ch, 0, num));  
9.         }  

// 第二种方式:通过字符数组进行读取.fr = new FileReader("FileWriterDemo.txt");// 定义一个字符数组,用于存储读取到的字符// 该read(char[])返回的是读到的字符个数char[] ch = new char[1024];int num = 0;while ((num = fr.read(ch)) != -1) {System.out.println(new String(ch, 0, num));}

综合使用字符输出输出流：

[java] view plaincopyprint?

1. // 从一个文件中读取出里面所有数据，然后写入另一个文件中   
2.         FileReader fr = new FileReader("demo.txt");  
3.         FileWriter fw = new FileWriter("demo2.txt");  
4.         char[] buf = new char[1024];  
5.         int len = 0;  
6.         while ((len = fr.read(buf)) != -1) {  
7.             fw.write(new String(buf, 0, len));  
8.         }  
9.         fw.close();  
10.         fr.close();  

// 从一个文件中读取出里面所有数据，然后写入另一个文件中FileReader fr = new FileReader("demo.txt");FileWriter fw = new FileWriter("demo2.txt");char[] buf = new char[1024];int len = 0;while ((len = fr.read(buf)) != -1) {fw.write(new String(buf, 0, len));}fw.close();fr.close();

为了提高对流的操作效率，使用了字符的缓冲区。

原理：其实就是将数组进行封装。在使用缓冲区对象时，要明确，缓冲的存在是为了增强流的功能而存在，所以在建立缓冲区对象时，要先有流对象存在。

字符流分别提供了两个类：BufferedReader：带缓冲区的字符输入流；BufferedWriter：带缓冲区的字符输出流。

这时我们可以对上面这个例子进行带缓冲的改造，从而提高操作效率：

其中：

readLine()方法的原理：

其实缓冲区中的该方法，用的还是与缓冲区关联的流对象的read方法。只不过，每一次读到一个字符，先不进行具体操作，先进行临时存储。当读取到回车标记时，将临时容器中存储的数据一次性返回。

注意：带缓冲区的输出流需要刷新，其实在close()时就会刷新缓冲区，但是当输出比较大的数据时，有可能缓冲区大小不够这时就需要刷新否则缓冲区的内容将会被覆盖。

3、字节流OutputStream/InputStream

字节流和字符流操作基本上都一致。下面拿一个复制MP3的例子来说明：

[java] view plaincopyprint?

1. // 复制方法1：   
2.     public static void copy_1() throws IOException {  
3.         FileInputStream fis = new FileInputStream("D:\\0.mp3");  
4.         FileOutputStream fos = new FileOutputStream("D:\\1.mp3");  
5.         byte[] buf = new byte[1024];  
6.         int len = 0;  
7.         while ((len = fis.read(buf)) != -1) {  
8.             fos.write(buf, 0, len);  
9.         }  
10.         fos.close();  
11.         fis.close();  
12.     }  
13.   
14.     // 方法2：已经用了缓冲流就不用再用缓冲区byte[] buf 了   
15.     public static void copy_2() throws IOException {  
16.         FileInputStream fis = new FileInputStream("D:\\0.mp3");  
17.         FileOutputStream fos = new FileOutputStream("D:\\2.mp3");  
18.         BufferedInputStream bufis = new BufferedInputStream(fis);  
19.         BufferedOutputStream bufos = new BufferedOutputStream(fos);  
20.         int ch = 0;  
21.         while ((ch = bufis.read()) != -1) {  
22.             bufos.write(ch);  
23.         }  
24.         bufos.close();  
25.         bufis.close();  
26.     }  
27.   
28.     // 方法3: 不建议，fis.available() 把一个文件大小都读进来了，如果文件过大，内存会用完  
29.     public static void copy_3() throws IOException {  
30.         FileInputStream fis = new FileInputStream("D:\\0.mp3");  
31.         FileOutputStream fos = new FileOutputStream("D:\\3.mp3");  
32.         byte[] buf = new byte[fis.available()];  
33.         fis.read(buf);  
34.         fos.write(buf);  
35.         fos.close();  
36.         fis.close();  
37.     }  
38.   
39.     // 方法4：读一个写一个,效率很差！   
40.     public static void copy_4() throws IOException {  
41.         FileInputStream fis = new FileInputStream("D:\\0.mp3");  
42.         FileOutputStream fos = new FileOutputStream("D:\\4.mp3");  
43.         int ch = 0;  
44.         while ((ch = fis.read()) != -1) {  
45.             fos.write(ch);  
46.         }  
47.         fos.close();  
48.         fis.close();  
49.     }  

// 复制方法1：public static void copy_1() throws IOException {FileInputStream fis = new FileInputStream("D:\\0.mp3");FileOutputStream fos = new FileOutputStream("D:\\1.mp3");byte[] buf = new byte[1024];int len = 0;while ((len = fis.read(buf)) != -1) {fos.write(buf, 0, len);}fos.close();fis.close();}// 方法2：已经用了缓冲流就不用再用缓冲区byte[] buf 了public static void copy_2() throws IOException {FileInputStream fis = new FileInputStream("D:\\0.mp3");FileOutputStream fos = new FileOutputStream("D:\\2.mp3");BufferedInputStream bufis = new BufferedInputStream(fis);BufferedOutputStream bufos = new BufferedOutputStream(fos);int ch = 0;while ((ch = bufis.read()) != -1) {bufos.write(ch);}bufos.close();bufis.close();}// 方法3: 不建议，fis.available() 把一个文件大小都读进来了，如果文件过大，内存会用完public static void copy_3() throws IOException {FileInputStream fis = new FileInputStream("D:\\0.mp3");FileOutputStream fos = new FileOutputStream("D:\\3.mp3");byte[] buf = new byte[fis.available()];fis.read(buf);fos.write(buf);fos.close();fis.close();}// 方法4：读一个写一个,效率很差！public static void copy_4() throws IOException {FileInputStream fis = new FileInputStream("D:\\0.mp3");FileOutputStream fos = new FileOutputStream("D:\\4.mp3");int ch = 0;while ((ch = fis.read()) != -1) {fos.write(ch);}fos.close();fis.close();}

其中：字节流可以处理所有类型数据，如图片，mp3，avi。如果是处理纯文本数据，就要优先考虑使用字符流。
3、（重点）流操作的基本规律

1.   明确源和目的

源：输入流，Reader、InputStream

目的：输出流，Writer、OutputStream

2.   操作的数据是否是纯文本

是：字符流

不是：字节流

3.   当体系明确后，在明确要使用哪个具体对象

通过设备来区分：

源设备：内存，硬盘，键盘

目的设备：内存，硬盘，控制台

范例 .将键盘录入的数据保存到一个文件中.

  源:输入流，Reader、InputStream

 是不是纯文本?  是! 用Reader

  设备:键盘,对应的对象是System.in

  不是选择Reader嘛? System.in对应的不是字节流InputStream嘛?

  为了操作键盘的文本数据方便,转成字符流按照字符串操作是最方便的.所以既然明确了Reader,那么就将System.in转成Reader.

  用Reader体系中的读取转换流InputStreamReader

  是否需要提高效率? 是! 用到Reader体系中的BufferedReader.

  InputStream in = System.in;

  InputStreamReader isr = new InputStreamReader(in);

  BufferedReader br = new BufferedReader(isr);

 目的:输出流，Writer、OutputStream

 是不是纯文本? 是! 用Writer

  设备:硬盘,txt文件.使用FileWriter

  是否需要提高效率? 是! 用到Writer体系中的BufferedWriter

   FileWriter fw = new FileWriter("xxx.txt");

   BufferedWriter bw = new BufferedWriter(fw);

4、流操作的基本规律

Reader和Writer各有一个子类：

                         |--InputStreamReader:读取转换流

                         |--OutputStreamWriter:写入转换流

（1）InputStreamReader:读取转换流

字节流读取的时候用的是一个一个字节的读取方式或者是字节数组的读取方式，

字符流中读取的时候，除了有一个一个字符的读取方式和数组 的读取 方式外 ，在缓冲技术里面有一行一行的读取，这个方法在读取的时候很好用也很方便，那么我们就可以把字节流的转换成字符流，然后利用缓冲对象来使用读取一行的方法。

（2）OutputStreamWriter:读取转换流

     OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的charset 将要写入流中的字符编码成字节。

代码：

[java] view plaincopyprint?

1. public static void main(String[] args) throws IOException {  
2.         // 获取键盘录入对象   
3.         // InputStream in = System.in;  
4.         // 将字节流对象转成字符流对象,使用转换流InputStreamReader  
5.         // InputStreamReader isr = new InputStreamReader(in);  
6.         // 为了提高效率,将字符串进行缓冲区技术高效操作.使用BufferedReader  
7.         // BufferedReader br = new BufferedReader(isr);  
8.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
9.   
10.           
11.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(  
12.                 System.out));  
13.   
14.         String s = null;  
15.         while ((s = br.readLine()) != null) {  
16.             if (s.equals("over"))  
17.                 break;  
18.             bw.write(s);  
19.             bw.newLine();  
20.             bw.flush();  
21.         }  
22.     }  

public static void main(String[] args) throws IOException {// 获取键盘录入对象// InputStream in = System.in;// 将字节流对象转成字符流对象,使用转换流InputStreamReader// InputStreamReader isr = new InputStreamReader(in);// 为了提高效率,将字符串进行缓冲区技术高效操作.使用BufferedReader// BufferedReader br = new BufferedReader(isr);BufferedReader br = new BufferedReader(new InputStreamReader(System.in));BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));String s = null;while ((s = br.readLine()) != null) {if (s.equals("over"))break;bw.write(s);bw.newLine();bw.flush();}}

当想要把录入的数据按照指定的编码表(utf-8)将数据存储到文件中，而指定的表码表只有转换流可以指定。

OutputStreamWriter(OutputStream out,String charsetName)
个人理解：通常涉及到字符编码转换时,需要用到转换流. 

[java] view plaincopyprint?

1. public static void main(String[] args) throws IOException {  
2.         // 源   
3.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
4.   
5.         FileOutputStream fos = new FileOutputStream("demo.txt");  
6.         // 默认的编码是jbk，这时指定编码为UTF-8   
7.         OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");  
8.         BufferedWriter bw = new BufferedWriter(osw);  
9.   
10.         String s = null;  
11.         while ((s = br.readLine()) != null) {  
12.             if (s.equals("over"))  
13.                 break;  
14.             bw.write(s);  
15.             bw.newLine();  
16.             bw.flush();  
17.         }  
18.     }  

public static void main(String[] args) throws IOException {// 源BufferedReader br = new BufferedReader(new InputStreamReader(System.in));FileOutputStream fos = new FileOutputStream("demo.txt");// 默认的编码是jbk，这时指定编码为UTF-8OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");BufferedWriter bw = new BufferedWriter(osw);String s = null;while ((s = br.readLine()) != null) {if (s.equals("over"))break;bw.write(s);bw.newLine();bw.flush();}}

5、IO异常处理方式

以例子说明：

[java] view plaincopyprint?

1. public static void main(String[] args) {  
2.         // 建立并初始化流   
3.         FileReader fr = null;  
4.         try {  
5.             fr = new FileReader("demo.txt");  
6.             // 定义一个字符数组,用于存储读取到的字符   
7.             // 该read(char[])返回的是读到的字符个数  
8.             char[] ch = new char[1024];  
9.             int num = 0;  
10.             while ((num = fr.read(ch)) != -1) {  
11.                 System.out.println(new String(ch, 0, num));  
12.             }  
13.         } catch (IOException e) {  
14.             System.out.println(e.toString());  
15.         } finally {  
16.             try {  
17.                 /* 
18.                  * 防止出现null异常,先判断fw是否为null，当还有其他流时，  
19.                  * 也应该像这样try_catch，再关闭流 
20.                  */  
21.                 if (fr != null)  
22.                     fr.close();  
23.             } catch (IOException e) {  
24.                 System.out.println(e.toString());  
25.             }  
26.         }  
27.     }  

public static void main(String[] args) {// 建立并初始化流FileReader fr = null;try {fr = new FileReader("demo.txt");// 定义一个字符数组,用于存储读取到的字符// 该read(char[])返回的是读到的字符个数char[] ch = new char[1024];int num = 0;while ((num = fr.read(ch)) != -1) {System.out.println(new String(ch, 0, num));}} catch (IOException e) {System.out.println(e.toString());} finally {try {/* * 防止出现null异常,先判断fw是否为null，当还有其他流时，  * 也应该像这样try_catch，再关闭流 */if (fr != null)fr.close();} catch (IOException e) {System.out.println(e.toString());}}}

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ -------------------------