12.3.2  字符流（1）
    在程序中一个字符等于两个字节，那么Java提供了Reader和Writer两个专门操作字符流的类。
     1．字符输出流Writer
    Writer本身是一个字符流的输出类，此类的定义如下：
            public abstract class Writer  extends Object  implements Appendable, Closeable, Flushable         此类本身也是一个抽象类，如果要使用此类，则肯定要使用其子类，此时如果是向文件中写入内容，应该使用FileWriter的子类。Wirter类的常用方法如表12-5所示。
    表12-5  Writer类的常用方法
                                                             序    号                 
                                                 方    法                 
                                                 类    型                 
                                                 描    述                 
                                                                             1                 
                                                 public abstract void close()                 
                                     hrows IOException                 
                                                 普通                 
                                                 关闭输出流                 
                                                                             2                 
                                                 public void write(String str)                 
                                      throws IOException                 
                                                 普通                 
                                                 将字符串输出                 
                                                                             3                 
                                                 public void write(char[] cbuf)                 
                                      throws IOException                 
                                                 普通                 
                                                 将字符数组输出                 
                                                                             4                 
                                                 public abstract void flush()                 
                                     throws IOException                 
                                                 普通                 
                                                 强制性清空缓存                 
                            FileWriter类的构造方法定义如下：
            public FileWriter(File file) throws IOException         U提示：关于Appendable接口的说明。
    在Writer类中除了实现Closeable和Flushable两个接口之外，还实现了一个Appendable接口，此接口定义如下：
            public interface Appendable{                      Appendable append(CharSequence csq) throws IOException ;                      Appendable append(CharSequence csq,int start,int end) throws IOException ;                      Appendable append(char c) throws IOException  ;
                        }         此接口表示的是内容可以被追加，接收的参数是CharSequence，实际上String类就实现了此接口，所以可以直接通过此接口的方法向输出流中追加内容。
    范例：向文件中写入数据
    读入 写出        
    
            package org.lxh.demo12.chariodemo;                  import java.io.File;                  import java.io.FileWriter;                  import java.io.Writer;                  public class WriterDemo01 {                     public static void main(String[] args)throws Exception { // 异常抛出，  不处理  
                                // 第1步：使用File类找到一个文件                          File f = new File("d:" + File.separator + "test.txt");// 声明File  对象                          // 第2步：通过子类实例化父类对象                          Writer out = null;               // 准备好一个输出的对象                          out = new FileWriter(f);         // 通过对象多态性，进行实例化                          // 第3步：进行写操作                          String str = "Hello World!!!";   // 准备一个字符串                          out.write(str);                 // 将内容输出      比较，读入时为 int len=input.read(byte[] b ) ;                        // 第4步：关闭输出流                          out.close();                  // 关闭输出流                      }                  }         整个程序与OutputStream的操作流程并没有什么太大的区别，唯一的好处是，可以直接输出字符串，而不用将字符串变为byte数组之后再输出。
    程序运行结果：
     12.3.2  字符流（2）     
     
     2．使用FileWriter追加文件的内容
    在使用字符流操作时，也可以实现文件的追加功能，直接使用FileWriter类中的以下构造即可实现追加：
            public FileWriter(File file,boolean append) throws IOException          将append的值设置为true，表示追加。
     范例：追加文件内容
            package org.lxh.demo12.chariodemo;                  import java.io.File;                  import java.io.FileWriter;                  import java.io.Writer;                  public class WriterDemo02 {                      public static void main(String[] args)throws Exception {   // 异常抛出，  不处理                          // 第1步：使用File类找到一个文件                          File f = new File("d:" + File.separator + "test.txt");  // 声明File  对象                          // 第2步：通过子类实例化父类对象                          Writer out = null;               // 准备好一个输出的对象                          out = new FileWriter(f,true);    // 通过对象多态性进行实例化                          // 第3步：进行写操作                          String str = "\r\nLIXINGHUA\r\nHelloWorld!!!" ; // 准备一个字符串                          out.write(str); // 将内容输出                          // 第4步：关闭输出流                          out.close();                        
        // 关闭输出流                      }                  }         程序运行结果：
                                           3．字符输入流Reader
    Reader是使用字符的方式从文件中取出数据，Reader类的定义如下：
            public abstract class Reader  extends Object  implements Readable, Closeable         Reader本身也是抽象类，如果现在要从文件中读取内容，则可以直接使用FileReader子类。Reader类的常用方法如表12-6所示。
    表12-6  Reader类的常用方法
                                                             序号                 
                                                 方    法                 
                                                 类型                 
                                                 描    述                 
                                                                             1                 
                                                 public abstract void close()                 
                                      throws IOException                 
                                                 普通                 
                                                 关闭输出流                 
                                                                             2                 
                                                 public int read() throws IOException                 
                                                 普通                 
                                                 读取单个字符                 
                                                                             3                 
                                                 public int read(char[] cbuf)                 
                                     throws IOException                 
                                                 普通                 
                                                 将内容读到字符数组中，                 
                                     返回读入的长度                 
                            FileReader的构造方法定义如下：
            public FileReader(File file) throws FileNotFoundException         范例：从文件中读取内容
            package org.lxh.demo12.chariodemo;                  import java.io.File;                  import java.io.FileReader;                  import java.io.Reader;                  public class ReaderDemo01 {                      public static void main(String[] args) throws Exception {   // 异常抛出，  不处理                              // 第1步：使用File类找到一个文件                          File f = new File("d:" + File.separator + "test.txt");// 声明File  对象                               // 第2步：通过子类实例化父类对象                          Reader reader = null;             // 准备好一个输入的对象                          reader = new FileReader(f);      // 通过对象多态性进行实例化                               // 第3步：进行读操作                          char c[] = new char[1024];       // 所有的内容读到此数组中                          int len = reader.read(c);       // 将内容输出                               // 第4步：关闭输入流                          reader.close();                  // 关闭输入流                          System.out.println("内容为：" + new String(c, 0, len));  // 把char数组变为字符串输出                      }                  }         程序运行结果：
             内容为：Hello World!!!                    LIXINGHUA                    Hello World!!!                    LIXINGHUA                    Hello World!!!          如果此时不知道数据的长度，也可以像之前操作字节流那样，使用循环的方式进行内容的读取。
    范例：使用循环的方式读取内容
             package org.lxh.demo12.chariodemo;                    import java.io.File;                    import java.io.FileReader;                    import java.io.Reader;                    public class ReaderDemo02 {                        public static void main(String[] args) throws Exception {   // 异常抛出，  不处理                            // 第1步：使用File类找到一个文件                            File f = new File("d:" + File.separator + "test.txt");// 声明File  对象                            // 第2步：通过子类实例化父类对象                            Reader reader = null;            // 准备好一个输入的对象                            reader = new FileReader(f);       // 通过对象多态性进行实例化                            // 第3步：进行读操作                            int len = 0;                     // 用于记录读取的数据个数                            char c[] = new char[1024];       // 所有的内容读到此数组中                            int temp = 0;                      // 接收读取的每一个内容                            while ((temp = reader.read()) != -1) {              // 将每次的读取内容给temp变量，如果temp的值不是-1，则表示文件没有读完                                c[len] = (char) temp;                                len++;                            }                            // 第4步：关闭输入流