黑马程序员——IO（FileWriter，FileReader）

IO(Input Output)流

Java用于操作流的对象都在IO包中。

流按操作数据分为两种：字节流与字符流。

流按流向分为：输入流，输出流。

IO流常用基类

字节流的抽象基类：

InputStream，OutputStream。记忆方法：根据Input联想System.in.从键盘输入。

也就是从键盘读数据，所以对应字符流的Reader。

      根据OUtput联想System.out。从控制台输出。

也就是写入控制台，对应字符流的Writer。

字符流的抽象基类：

Reader，Writer。

注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：imputStream的子类FileInputStream。

如：Reader的子类FileReader。

字符流：

既然IO流是用于操作数据的，

那么数据的最常见体现形式是：文件。

那么先以操作文件为主来演示。

需求：

在硬盘上创建一个文件并写入一些文字数据。

专门用于操作文件的Writer子类对象。FileWriter。后缀名是父类名。前缀名是该流对象的功能。

FileWriter类操作演示：

[java]  view plain copy print ?

1. import java.io.FileWriter;  
2. import java.io.IOException;  
3.   
4.   
5. public class FileWriterDemo {  
6.   
7.     public static void main(String[] args) throws IOException   
8.     {  
9.     //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。  
10.     //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。  
11.     FileWriter fw = new FileWriter("demo.txt");  
12.       
13.     //调用wirt方法，将字符串写入到流中。  
14.     fw.write("abcde");  
15.       
16.     //刷新流对象中的缓冲中的数据。将数据刷新到目的地。  
17.     //fw.flush();  
18.       
19.     //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。  
20.     //和flush区别：flush刷新后，流可以继续使用，close刷新后，就将流关闭。  
21.     fw.close();  
22.     }  
23. }  

IO异常的基本处理方式：

[java]  view plain copy print ?

1. import java.io.FileWriter;  
2. import java.io.IOException;  
3.   
4.   
5. /* 
6.     IO异常的处理方式。 
7.  */  
8.   
9.   
10. public class FileWriterDemo2 {  
11.   
12.     public static void main(String[] args)   
13.     {  
14.         FileWriter fw = null;//建立引用  
15.         try {  
16.             fw = new FileWriter("demo.txt");  
17.               
18.             fw.write("abcdefg");  
19.               
20.               
21.         } catch (IOException e) {  
22.               
23.             e.printStackTrace();  
24.         }  
25.         finally  
26.         {  
27.             try {  
28.                 if(fw!=null)//一定要进行不等于null判断。  
29.                     fw.close();//必须写在finally里面  
30.             } catch (IOException e) {  
31.                 // TODO 自动生成的 catch 块  
32.                 e.printStackTrace();  
33.             }  
34.         }  
35.           
36.     }  
37.   
38. }  

FileWriter(String fileName, boolean append)

根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter对象。

[java]  view plain copy print ?

1. import java.io.FileWriter;  
2. import java.io.IOException;  
3.   
4.   
5. /* 
6.  <strong>演示对已有文件的数据续写。</strong> 
7.  */  
8.   
9.   
10. public class FileWriterDemo3 {  
11.   
12.     public static void main(String[] args) throws IOException   
13.     {  
14.           
15.         FileWriter fw = new FileWriter("java.txt",true);//代表可以续写。  
16.         //windows换行符（\r\n）,不识别（\n）的换行符。  
17.         fw.write("abc\r\ndef");  
18.         fw.close();  
19.     }  
20. }  

数据读取：

Reader类：

public class FileReader extends InputStreamReader

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小适当。

读取方法：

public int read()

返回整数读取的字符，如果已达到末尾，则返回-1；

public int read(char[] cbuf)

读取的字符数，如果已达流的末尾，则返回-1；

[java]  view plain copy print ?

1. import java.io.FileNotFoundException;  
2. import java.io.FileReader;  
3. import java.io.IOException;  
4.   
5.   
6. public class FileReaderDemo {  
7.   
8.     public static void main(String[] args) throws IOException   
9.     {  
10.         //创建一个文件读取流对象，和指定名称的文件相关联。  
11.         //要保证该文件是已经存在的，如果不存在，会发生异常。FileNotFoundException。  
12.         FileReader fr = new FileReader("java.txt");<strong>  
13.           
14.         </strong>//调用读取流对象的read方法。  
15.         //read(): 一次读取一个字符。而且会自动下读。  
16.         //int ch;  
17.         //while((ch = fr.read())!=-1)//read（）如果读到流的末尾，则返回-1；  
18.             //System.out.print((char)ch);  
19.         char[] cbuf = new char[1024];  
20.         int num;  
21.         while((num=fr.read(cbuf))!=-1)  
22.         System.out.println(num+"..."+new String(cbuf));  
23.   
24.         fr.close();  
25.     }  
26. }<strong>  
27. </strong>  

练习：

[java]  view plain copy print ?

1. import java.io.FileReader;  
2. import java.io.IOException;  
3. //读取一个.java,并打印在控制台上。  
4.   
5. public class FileReaderTest {  
6.   
7.     public static void main(String[] args)   
8.     {  
9.         FileReader fr = null;  
10.         try {  
11.             fr = new FileReader(".\\src\\FileReaderTest.java");  
12.             char[] ch = new char[1024];  
13.             while(fr.read(ch)!=-1)  
14.                 System.out.print(new String(ch).toString());  
15.         } catch (IOException e) {  
16.               
17.         }  
18.         finally  
19.         {  
20.                 try {  
21.                     if(fr!=null)  
22.                         fr.close();  
23.                 } catch (IOException e) {  
24.                     e.printStackTrace();  
25.                 }  
26.         }  
27.     }  
28.   
29. }  

练习：复制文件

[java]  view plain copy print ?

1. import java.io.FileReader;  
2. import java.io.FileWriter;  
3. import java.io.IOException;  
4. //读取一个.java,并打印在控制台上。  
5.   
6. public class FileReaderTest {  
7.   
8.     public static void main(String[] args)   
9.     {  
10.         FileReader fr = null;  
11.         FileWriter  fw = null;  
12.         try {  
13.             fr = new FileReader(".\\src\\FileReaderTest.java");  
14.             fw = new FileWriter("FileReaderTest.java");  
15.             char[] ch = new char[1024];  
16.             int len = 0;  
17.             while((len=fr.read(ch))!=-1)  
18.                 <strong>fw.write(ch,0,len);</strong>  
19.         } catch (IOException e)   
20.         {  
21.             throw new RuntimeException("读写失败");  
22.         }  
23.         finally  
24.         {  
25.                 try {  
26.                     if(fr!=null)  
27.                         fr.close();  
28.                     if(fw!=null)  
29.                         fw.close();  
30.                 } catch (IOException e) {  
31.                     throw new RuntimeException("读写失败");  
32.                 }  
33.         }  
34.     }  
35.   
36. }