Java基础之IO流知识点总结一

Io流的整体把握：

          

其他常用与流相关的对象:

     

             IO流  总结一

IO流：用于处理设备上的数据。
   设备：硬盘、内存、键盘输入。

IO有具体的分类：
   1． 根据流向的不同：输入流和输出流
   2． 根据操作数据的不同：字节流和字符流

问：有了字节流的存在，为什么字符流还要出现？
   字符流的由来：因为文件编码的不同，才出现了字符流，它可以对字符进行高效的操作。
   原理：其实字符流就是基于字节流读取字节时，去查询了指定的码表。

那么字节流和字符流有哪些区别呢？
    区别：
      1. 字节流读取数据的时候，读到一个字节就返回一个字节。而字符流就不同了，字符流使用了字节流读到一个或者多个字节（为啥？会读到多个字节：因为中文对应的字节数是两个，在UTF-8码表中是三个字节）时。先去查指定的编码表，将查到的字符返回。

      2. 字节流可以处理所有类型的数据，比如：图片、MP3音乐，avi格式的视频等。但是字符流只能处理字符数据。

      再次，总结字符流和字节流，可以得出结论：只要是处理纯文本数据时，就要优先考虑使用字符流，除此之外都用字节流。

IO的体系。我们要知道IO流的两个基本的功能：读和写。
     1. 字节流的抽象基类：
          InputStream（读）,OutputStream（写）
     2. 字符流的抽象基类：
          Reader（读），Writer（写）

IO基本的读写操作方式：
      因为数据通常都是以文件形式存在的，所以就要找到IO体系中可以用于操作文件的流对象。通过名称可以很容易的获取该对象，因为IO体系中的子类名后缀绝大部分是父类名称，而前缀都是体现子类功能名字。

下面举个例子说明一下：
Reader
    |--InputStreamReader:专门用于处理文件的字节读取流对象
           |--FileReader:专门用于处理文件的字符读取流对象 
Writer
    |--OutputStreamWriter专门用于处理文件的字节写入流对象
           |--FileWriter:专门用于处理文件的字符写入流对象

Writer中常见的方法：
  1. writer(ch):将一个字符写入到流中。
  2. writer(char[]):将一个字符数组写入到流中。
  3. writer(String):将一个字符串写入到流中。
  4. flush():刷新流，将流中的数据刷新到目的地中，流还存在。
  5. close():关闭资源，在关闭前会先调用flush(),刷新流中的数据去目的地，然后流才关闭。

Reader中常见到的方法：
  1. int read():读取一个字符。返回的是读到的那个字符。如果读到流的末尾，返回-1。
  2. int read(char[]):将读到的字符存入到数组中，返回的是读到的字符个数，也就是往数组里装的元素的个数。如果读到了流的末尾，返回-1。
  3. close():关闭字符流其实用的是window系统的功能，就希望使用完毕后，要对资源进行释放。

    FileWriter:
      该类没有特有的方法。只有自己的构造函数。
      该类的特点在于：
        1. 用于处理文本文件。
        2. 该类中有默认的编码表。
        3. 该类中有临时缓冲。
      构造函数：在写入流对象初始化时，必须要有一个存储数据的目的地。
    FileWriter(String filename):
      该构造函数做了什么事情呢？
        1. 调用系统资源。
        2. 在指定位置，创建了一个文件。注意：如果该文件已存在，将会被覆盖。
    FileWriter(String filename,Boolean append):该构造函数：当传入的boolean类型值为true时，会在指定的文件末尾处进行数据的续写。

    FileReader:
      1. 用于读取文本文件的流对象。
      2. 用于关联文本文件
      构造函数：在读取流对象初始化的时候，必须要指定一个被读取的文件。如果该文件不存在，会报FileNotFoundException的异常。
    FileReader(String filename);

例子1：在硬盘上，创建一个文件并写入一些文字数据。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileWriter;  
3. import java.io.IOException;  
4. /** 
5.  * 需求：在硬盘上，创建一个文件并写入一些文字数据。 
6.  * 解析：这里就找到了专门操作文件的Writer子类对象FileWriter， 
7.  * 它的后缀名是父类名，前缀名是自己所具有的功能 
8.  * @author wl-pc 
9. */  
10. public class FileWriterDemo {  
11.   
12.     public static void main(String[] args) throws IOException {  
13.   
14.       //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。  
15.       //而且，该文件会被创建到指定的目录下，指定的文件名。如果该目录下已有  
16.       //同名文件，那么原文件将会被覆盖。其实该步就是要明确数据存放的目的地。  
17.       //出现IO异常  方法1：抛出异常 方法2：try...catch...异常   
18.           FileWriter fw = new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo.txt");     
19.           
20.       //调用write()方法，将字符串写入到流中  
21.       fw.write("hello world!");     
22.       //刷新流对象中的缓冲的数据，将数据刷新到目的地中  
23.       fw.flush();  
24.       fw.write("wangling!");  
25.       //close()关闭流资源，但是在关闭之前会刷新一次内部缓冲区中的数据，将数据  
26.       //刷到目的地中和flush()区别：flush()刷新后，流可以继续使用，但是close()刷新后，会将流关闭  
27.       fw.close();  
28.     }  
29. }  

上面的示例代码没有用到try...catch代码块处理异常下面给出完整的代码处理方式。

例子2：完整的异常处理方式的代码实例演示。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileWriter;  
3. import java.io.IOException;  
4. public class FileWriterDemo2 {  
5.     public static void main(String[] args) {  
6.         FileWriter fw=null;  
7.         try {  
8.                  fw = new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");  
9.             fw.write("hello world!");  
10.             fw.flush();  
11.         } catch (IOException e) {  
12.             System.out.println(e.toString());  
13.         } finally{  
14.             if(fw!=null){  
15.                 try {  
16.                     fw.close();  
17.                 } catch (IOException e) {  
18.                     System.out.println("close:"+e.toString());  
19.                 }  
20.             }  
21.         }     
22.     }  
23. }  

发现的小细节：     当指定绝对路径时，定义目录分隔符有两种方式：        1.  反斜线 但是一定要写两个。例：new FileWriter(c:\\emo.txt);        2.  斜线  / 写一个即可。例：newFileWriter(c:/demo.txt); 例子3：对已经存在文件的内容进行续写。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileWriter;  
3. import java.io.IOException;  
4. /** 
5.  * 演示：对已有数据的续写 
6.  * @author wl-pc 
7. */  
8. public class FileWriterDemo3 {  
9.     public static void main(String[] args) {  
10.         FileWriter fw = null;  
11.         try {  
12.            //传递一个true参数，代表不覆盖已有的文件，并在已有的文件的末尾处进行数据的添加  
13.                fw=new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt",true);  
14.            fw.write("nihao!\r\nxiaoming");    // \r\n表示换行标记  
15.            fw.flush();  
16.         } catch (IOException e) {  
17.            System.out.println(e.toString());  
18.         }finally{  
19.            if(fw!=null){  
20.             try {  
21.                 fw.close();  
22.             } catch (IOException e) {  
23.                 System.out.println("close:"+e.toString());  
24.                 }  
25.            }  
26.           }  
27.     }  
28. }  

例子4：读取一个已有的文本文件，将文本数据打印出来。（注意：一次读一个字符就打印出来，效率不高。）

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. public class FileReaderDemo1 {  
6.     public static void main(String[] args) {  
7.         FileReader fr = null;  
8.         try {  
9.             //创建一个文件读取流对象，和指定名称的文件相关联  
10.             //要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)  
11.             fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");  
12.             //调用读取流对象的read()方法  
13.             int ch = 0;  
14.             try {  
15.                 while((ch=fr.read())!=-1){   //数据读到结尾，返回结果为-1  
16.                     System.out.println("ch="+(char)ch);  
17.                 }  
18.             } catch (IOException e) {  
19.                 System.out.println(e.toString());  
20.             }  
21.         } catch (FileNotFoundException e) {  
22.             System.out.println(e.toString());  
23.         } finally{  
24.             if(fr != null){  
25.                 try {  
26.                     fr.close();  
27.                 } catch (IOException e) {  
28.                     System.out.println("close:"+e.toString());  
29.                 }  
30.             }  
31.         }  
32.     }  
33. }  

例子5：读取一个已有的文本文件，将文本数据打印出来。（注意：使用while循环把所有的字符都打印出来。）

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. public class FileReaderDemo1 {  
6.     public static void main(String[] args) {  
7.         FileReader fr = null;  
8.         try {  
9.             //创建一个文件读取流对象，和指定名称的文件相关联  
10.             //要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)  
11.             fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");  
12.             //调用读取流对象的read()方法  
13.             int ch = 0;  
14.             try {  
15.                 while((ch=fr.read())!=-1){   //数据读到结尾，返回结果为-1  
16.                     System.out.println("ch="+(char)ch);  
17.                 }  
18.             } catch (IOException e) {  
19.                 System.out.println(e.toString());  
20.             }  
21.         } catch (FileNotFoundException e) {  
22.             System.out.println(e.toString());  
23.         } finally{  
24.             if(fr != null){  
25.                 try {  
26.                     fr.close();  
27.                 } catch (IOException e) {  
28.                     System.out.println("close:"+e.toString());  
29.                 }  
30.             }  
31.         }  
32.     }  
33. }  

例子6：读一个字符就存入字符数组里，读完1Kb再打印。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. public class FileReaderDemo2 {  
6.     public static void main(String[] args) {  
7.         FileReader fr = null;  
8.         try {  
9.             //创建一个文件读取流对象，和指定名称的文件相关联  
10.             //要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)  
11.             fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");  
12.             char[] buf = new char[1024];  //该长度通常是1024的整数倍  
13.             int len = 0;  
14.             try {  
15.                 while((len=fr.read(buf))!=-1){  
16.                                 //使用String(char[] value,int offset,int count)分配  
17.                 //一个新的String,它包含取自字符数组参数一个子数组的字符  
18.                 System.out.println(new String(buf,0,len));  
19.                 }  
20.             } catch (IOException e) {  
21.                 System.out.println(e.toString());  
22.             }     
23.         } catch (FileNotFoundException e) {  
24.             System.out.println(e.toString());  
25.         } finally{  
26.             if(fr != null){  
27.                 try {  
28.                     fr.close();  
29.                 } catch (IOException e) {  
30.                     System.out.println("close:"+e.toString());  
31.                 }  
32.             }  
33.         }  
34.     }  
35. }  

例子7：读取一个*.java的文件，并且打印在控制台上

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. /** 
6.  * 演示：读取一个*.java的文件，并且打印在控制台上 
7.  * @author wl-pc 
8. */  
9. public class FileReaderTest {  
10.     public static void main(String[] args) {  
11.         FileReader fr=null;  
12.         try {  
13.             fr = new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.java");  
14.             char[] buf = new char[1024];  
15.             int len = 0;  
16.             try {  
17.                 while((len = fr.read(buf))!=-1){  
18.                     System.out.println(new String(buf,0,len));  
19.                 }  
20.             } catch (IOException e) {  
21.                 System.out.println(e.toString());  
22.             }  
23.         } catch (FileNotFoundException e) {  
24.             System.out.println(e.toString());  
25.         } finally{  
26.             if(fr!=null) {  
27.                 try {  
28.                     fr.close();  
29.                 } catch (IOException e) {  
30.                     System.out.println(e.toString());  
31.                 }  
32.             }  
33.         }  
34.     }  
35. }  

例子8：将f盘中的一个文件复制到f盘一个另文本文件中。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileReader;  
3. import java.io.FileWriter;  
4. import java.io.IOException;  
5. /** 
6.  * 将f盘中的一个文件复制到f盘一个另文本文件中 
7.  * 复制原理：其实就是将c盘下的文件数据存储到d盘的一个文件中 
8.  * @author wl-pc  
9.  * 步骤：1.在d盘创建一个文件，用于存储c盘文件中的数据  
10.  *       2.定义一个读取流，和c盘文件关联 
11.  *       3.通过不断的读写完成数据的copy 
12.  *       4.关闭资源 
13.  */  
14. public class CopyText {  
15.     public static void main(String[] args) {  
16.         // copy_1();  
17.            copy_2();  
18.     }  
19.   
20.     // 第一种copy的方法  
21.     public static void copy_1() {  
22.         FileWriter fw = null;  
23.         FileReader fr = null;  
24.         try {  
25.             // 创建目的地  
26.             fw = new FileWriter(  
27.                     "F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\RuntimeDemo_copy.txt");  
28.             // 与已有文件关联  
29.             fr = new FileReader(  
30.                     "F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.java");  
31.             // 一次读取一个字符直接写了一次到txt文本中，速度慢  
32.             int ch = 0;  
33.             while ((ch = fr.read()) != -1) {  
34.                 fw.write(ch);  
35.             }  
36.             fr.close();  
37.             fw.close();  
38.         } catch (IOException e) {  
39.             System.out.println(e.toString());  
40.         } finally {  
41.             if (fw != null) {  
42.                 try {  
43.                     fw.close();  
44.                 } catch (IOException e) {  
45.                     System.out.println("close:" + e.toString());  
46.                 }  
47.             }  
48.         }  
49.     }  
50.   
51.     // 第二种copy的方法  
52.     public static void copy_2() {  
53.         FileWriter fw = null;  
54.         FileReader fr = null;  
55.         try {  
56.             // 创建目的地  
57.             fw = new FileWriter(  
58.                     "F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\RuntimeDemo_copy1.txt");  
59.             // 与已有文件关联  
60.             fr = new FileReader(  
61.                     "F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.java");  
62.             char[] buf = new char[1024];  
63.             int len = 0;  
64.             while ((len = fr.read(buf)) != -1) {  
65.                 fw.write(buf, 0, len);  
66.             }  
67.         } catch (IOException e) {  
68.             //抛出运行时异常  
69.             throw new RuntimeException("读写失败");  
70.         } finally {  
71.             //关闭流要一个一个的关闭，不要一起关闭  
72.             if (fw != null) {  
73.                 try {  
74.                     fw.close();  
75.                 } catch (IOException e) {  
76.                     System.out.println("close:" + e.toString());  
77.                 }  
78.             }  
79.             if (fr != null) {  
80.                 try {  
81.                     fr.close();  
82.                 } catch (IOException e) {  
83.                     System.out.println("close:" + e.toString());  
84.                 }  
85.             }  
86.         }  
87.     }  
88. }  

Io流的整体把握：

          

其他常用与流相关的对象:

     

             IO流  总结一

IO流：用于处理设备上的数据。
   设备：硬盘、内存、键盘输入。

IO有具体的分类：
   1． 根据流向的不同：输入流和输出流
   2． 根据操作数据的不同：字节流和字符流

问：有了字节流的存在，为什么字符流还要出现？
   字符流的由来：因为文件编码的不同，才出现了字符流，它可以对字符进行高效的操作。
   原理：其实字符流就是基于字节流读取字节时，去查询了指定的码表。

那么字节流和字符流有哪些区别呢？
    区别：
      1. 字节流读取数据的时候，读到一个字节就返回一个字节。而字符流就不同了，字符流使用了字节流读到一个或者多个字节（为啥？会读到多个字节：因为中文对应的字节数是两个，在UTF-8码表中是三个字节）时。先去查指定的编码表，将查到的字符返回。

      2. 字节流可以处理所有类型的数据，比如：图片、MP3音乐，avi格式的视频等。但是字符流只能处理字符数据。

      再次，总结字符流和字节流，可以得出结论：只要是处理纯文本数据时，就要优先考虑使用字符流，除此之外都用字节流。

IO的体系。我们要知道IO流的两个基本的功能：读和写。
     1. 字节流的抽象基类：
          InputStream（读）,OutputStream（写）
     2. 字符流的抽象基类：
          Reader（读），Writer（写）

IO基本的读写操作方式：
      因为数据通常都是以文件形式存在的，所以就要找到IO体系中可以用于操作文件的流对象。通过名称可以很容易的获取该对象，因为IO体系中的子类名后缀绝大部分是父类名称，而前缀都是体现子类功能名字。

下面举个例子说明一下：
Reader
    |--InputStreamReader:专门用于处理文件的字节读取流对象
           |--FileReader:专门用于处理文件的字符读取流对象 
Writer
    |--OutputStreamWriter专门用于处理文件的字节写入流对象
           |--FileWriter:专门用于处理文件的字符写入流对象

Writer中常见的方法：
  1. writer(ch):将一个字符写入到流中。
  2. writer(char[]):将一个字符数组写入到流中。
  3. writer(String):将一个字符串写入到流中。
  4. flush():刷新流，将流中的数据刷新到目的地中，流还存在。
  5. close():关闭资源，在关闭前会先调用flush(),刷新流中的数据去目的地，然后流才关闭。

Reader中常见到的方法：
  1. int read():读取一个字符。返回的是读到的那个字符。如果读到流的末尾，返回-1。
  2. int read(char[]):将读到的字符存入到数组中，返回的是读到的字符个数，也就是往数组里装的元素的个数。如果读到了流的末尾，返回-1。
  3. close():关闭字符流其实用的是window系统的功能，就希望使用完毕后，要对资源进行释放。

    FileWriter:
      该类没有特有的方法。只有自己的构造函数。
      该类的特点在于：
        1. 用于处理文本文件。
        2. 该类中有默认的编码表。
        3. 该类中有临时缓冲。
      构造函数：在写入流对象初始化时，必须要有一个存储数据的目的地。
    FileWriter(String filename):
      该构造函数做了什么事情呢？
        1. 调用系统资源。
        2. 在指定位置，创建了一个文件。注意：如果该文件已存在，将会被覆盖。
    FileWriter(String filename,Boolean append):该构造函数：当传入的boolean类型值为true时，会在指定的文件末尾处进行数据的续写。

    FileReader:
      1. 用于读取文本文件的流对象。
      2. 用于关联文本文件
      构造函数：在读取流对象初始化的时候，必须要指定一个被读取的文件。如果该文件不存在，会报FileNotFoundException的异常。
    FileReader(String filename);

例子1：在硬盘上，创建一个文件并写入一些文字数据。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileWriter;  
3. import java.io.IOException;  
4. /** 
5.  * 需求：在硬盘上，创建一个文件并写入一些文字数据。 
6.  * 解析：这里就找到了专门操作文件的Writer子类对象FileWriter， 
7.  * 它的后缀名是父类名，前缀名是自己所具有的功能 
8.  * @author wl-pc 
9. */  
10. public class FileWriterDemo {  
11.   
12.     public static void main(String[] args) throws IOException {  
13.   
14.       //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。  
15.       //而且，该文件会被创建到指定的目录下，指定的文件名。如果该目录下已有  
16.       //同名文件，那么原文件将会被覆盖。其实该步就是要明确数据存放的目的地。  
17.       //出现IO异常  方法1：抛出异常 方法2：try...catch...异常   
18.           FileWriter fw = new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo.txt");     
19.           
20.       //调用write()方法，将字符串写入到流中  
21.       fw.write("hello world!");     
22.       //刷新流对象中的缓冲的数据，将数据刷新到目的地中  
23.       fw.flush();  
24.       fw.write("wangling!");  
25.       //close()关闭流资源，但是在关闭之前会刷新一次内部缓冲区中的数据，将数据  
26.       //刷到目的地中和flush()区别：flush()刷新后，流可以继续使用，但是close()刷新后，会将流关闭  
27.       fw.close();  
28.     }  
29. }  

上面的示例代码没有用到try...catch代码块处理异常下面给出完整的代码处理方式。

例子2：完整的异常处理方式的代码实例演示。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileWriter;  
3. import java.io.IOException;  
4. public class FileWriterDemo2 {  
5.     public static void main(String[] args) {  
6.         FileWriter fw=null;  
7.         try {  
8.                  fw = new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");  
9.             fw.write("hello world!");  
10.             fw.flush();  
11.         } catch (IOException e) {  
12.             System.out.println(e.toString());  
13.         } finally{  
14.             if(fw!=null){  
15.                 try {  
16.                     fw.close();  
17.                 } catch (IOException e) {  
18.                     System.out.println("close:"+e.toString());  
19.                 }  
20.             }  
21.         }     
22.     }  
23. }  

发现的小细节：     当指定绝对路径时，定义目录分隔符有两种方式：        1.  反斜线 但是一定要写两个。例：new FileWriter(c:\\emo.txt);        2.  斜线  / 写一个即可。例：newFileWriter(c:/demo.txt); 例子3：对已经存在文件的内容进行续写。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileWriter;  
3. import java.io.IOException;  
4. /** 
5.  * 演示：对已有数据的续写 
6.  * @author wl-pc 
7. */  
8. public class FileWriterDemo3 {  
9.     public static void main(String[] args) {  
10.         FileWriter fw = null;  
11.         try {  
12.            //传递一个true参数，代表不覆盖已有的文件，并在已有的文件的末尾处进行数据的添加  
13.                fw=new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt",true);  
14.            fw.write("nihao!\r\nxiaoming");    // \r\n表示换行标记  
15.            fw.flush();  
16.         } catch (IOException e) {  
17.            System.out.println(e.toString());  
18.         }finally{  
19.            if(fw!=null){  
20.             try {  
21.                 fw.close();  
22.             } catch (IOException e) {  
23.                 System.out.println("close:"+e.toString());  
24.                 }  
25.            }  
26.           }  
27.     }  
28. }  

例子4：读取一个已有的文本文件，将文本数据打印出来。（注意：一次读一个字符就打印出来，效率不高。）

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. public class FileReaderDemo1 {  
6.     public static void main(String[] args) {  
7.         FileReader fr = null;  
8.         try {  
9.             //创建一个文件读取流对象，和指定名称的文件相关联  
10.             //要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)  
11.             fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");  
12.             //调用读取流对象的read()方法  
13.             int ch = 0;  
14.             try {  
15.                 while((ch=fr.read())!=-1){   //数据读到结尾，返回结果为-1  
16.                     System.out.println("ch="+(char)ch);  
17.                 }  
18.             } catch (IOException e) {  
19.                 System.out.println(e.toString());  
20.             }  
21.         } catch (FileNotFoundException e) {  
22.             System.out.println(e.toString());  
23.         } finally{  
24.             if(fr != null){  
25.                 try {  
26.                     fr.close();  
27.                 } catch (IOException e) {  
28.                     System.out.println("close:"+e.toString());  
29.                 }  
30.             }  
31.         }  
32.     }  
33. }  

例子5：读取一个已有的文本文件，将文本数据打印出来。（注意：使用while循环把所有的字符都打印出来。）

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. public class FileReaderDemo1 {  
6.     public static void main(String[] args) {  
7.         FileReader fr = null;  
8.         try {  
9.             //创建一个文件读取流对象，和指定名称的文件相关联  
10.             //要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)  
11.             fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");  
12.             //调用读取流对象的read()方法  
13.             int ch = 0;  
14.             try {  
15.                 while((ch=fr.read())!=-1){   //数据读到结尾，返回结果为-1  
16.                     System.out.println("ch="+(char)ch);  
17.                 }  
18.             } catch (IOException e) {  
19.                 System.out.println(e.toString());  
20.             }  
21.         } catch (FileNotFoundException e) {  
22.             System.out.println(e.toString());  
23.         } finally{  
24.             if(fr != null){  
25.                 try {  
26.                     fr.close();  
27.                 } catch (IOException e) {  
28.                     System.out.println("close:"+e.toString());  
29.                 }  
30.             }  
31.         }  
32.     }  
33. }  

例子6：读一个字符就存入字符数组里，读完1Kb再打印。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. public class FileReaderDemo2 {  
6.     public static void main(String[] args) {  
7.         FileReader fr = null;  
8.         try {  
9.             //创建一个文件读取流对象，和指定名称的文件相关联  
10.             //要保障此文件已存在，如果不存在，会发生异常(FileNotException异常)  
11.             fr=new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\demo2.txt");  
12.             char[] buf = new char[1024];  //该长度通常是1024的整数倍  
13.             int len = 0;  
14.             try {  
15.                 while((len=fr.read(buf))!=-1){  
16.                                 //使用String(char[] value,int offset,int count)分配  
17.                 //一个新的String,它包含取自字符数组参数一个子数组的字符  
18.                 System.out.println(new String(buf,0,len));  
19.                 }  
20.             } catch (IOException e) {  
21.                 System.out.println(e.toString());  
22.             }     
23.         } catch (FileNotFoundException e) {  
24.             System.out.println(e.toString());  
25.         } finally{  
26.             if(fr != null){  
27.                 try {  
28.                     fr.close();  
29.                 } catch (IOException e) {  
30.                     System.out.println("close:"+e.toString());  
31.                 }  
32.             }  
33.         }  
34.     }  
35. }  

例子7：读取一个*.java的文件，并且打印在控制台上

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.io.IOException;  
5. /** 
6.  * 演示：读取一个*.java的文件，并且打印在控制台上 
7.  * @author wl-pc 
8. */  
9. public class FileReaderTest {  
10.     public static void main(String[] args) {  
11.         FileReader fr=null;  
12.         try {  
13.             fr = new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.java");  
14.             char[] buf = new char[1024];  
15.             int len = 0;  
16.             try {  
17.                 while((len = fr.read(buf))!=-1){  
18.                     System.out.println(new String(buf,0,len));  
19.                 }  
20.             } catch (IOException e) {  
21.                 System.out.println(e.toString());  
22.             }  
23.         } catch (FileNotFoundException e) {  
24.             System.out.println(e.toString());  
25.         } finally{  
26.             if(fr!=null) {  
27.                 try {  
28.                     fr.close();  
29.                 } catch (IOException e) {  
30.                     System.out.println(e.toString());  
31.                 }  
32.             }  
33.         }  
34.     }  
35. }  

例子8：将f盘中的一个文件复制到f盘一个另文本文件中。

[java] view plain copy

1. package cn.itheima.day02;  
2. import java.io.FileReader;  
3. import java.io.FileWriter;  
4. import java.io.IOException;  
5. /** 
6.  * 将f盘中的一个文件复制到f盘一个另文本文件中 
7.  * 复制原理：其实就是将c盘下的文件数据存储到d盘的一个文件中 
8.  * @author wl-pc  
9.  * 步骤：1.在d盘创建一个文件，用于存储c盘文件中的数据  
10.  *       2.定义一个读取流，和c盘文件关联 
11.  *       3.通过不断的读写完成数据的copy 
12.  *       4.关闭资源 
13.  */  
14. public class CopyText {  
15.     public static void main(String[] args) {  
16.         // copy_1();  
17.            copy_2();  
18.     }  
19.   
20.     // 第一种copy的方法  
21.     public static void copy_1() {  
22.         FileWriter fw = null;  
23.         FileReader fr = null;  
24.         try {  
25.             // 创建目的地  
26.             fw = new FileWriter(  
27.                     "F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\RuntimeDemo_copy.txt");  
28.             // 与已有文件关联  
29.             fr = new FileReader(  
30.                     "F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.java");  
31.             // 一次读取一个字符直接写了一次到txt文本中，速度慢  
32.             int ch = 0;  
33.             while ((ch = fr.read()) != -1) {  
34.                 fw.write(ch);  
35.             }  
36.             fr.close();  
37.             fw.close();  
38.         } catch (IOException e) {  
39.             System.out.println(e.toString());  
40.         } finally {  
41.             if (fw != null) {  
42.                 try {  
43.                     fw.close();  
44.                 } catch (IOException e) {  
45.                     System.out.println("close:" + e.toString());  
46.                 }  
47.             }  
48.         }  
49.     }  
50.   
51.     // 第二种copy的方法  
52.     public static void copy_2() {  
53.         FileWriter fw = null;  
54.         FileReader fr = null;  
55.         try {  
56.             // 创建目的地  
57.             fw = new FileWriter(  
58.                     "F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\RuntimeDemo_copy1.txt");  
59.             // 与已有文件关联  
60.             fr = new FileReader(  
61.                     "F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day02\\FileWriterDemo2.java");  
62.             char[] buf = new char[1024];  
63.             int len = 0;  
64.             while ((len = fr.read(buf)) != -1) {  
65.                 fw.write(buf, 0, len);  
66.             }  
67.         } catch (IOException e) {  
68.             //抛出运行时异常  
69.             throw new RuntimeException("读写失败");  
70.         } finally {  
71.             //关闭流要一个一个的关闭，不要一起关闭  
72.             if (fw != null) {  
73.                 try {  
74.                     fw.close();  
75.                 } catch (IOException e) {  
76.                     System.out.println("close:" + e.toString());  
77.                 }  
78.             }  
79.             if (fr != null) {  
80.                 try {  
81.                     fr.close();  
82.                 } catch (IOException e) {  
83.                     System.out.println("close:" + e.toString());  
84.                 }  
85.             }  
86.         }  
87.     }  
88. }