1.   (1)IO流的四个基类
    A:字节流      字节输入流        InputStream       字节输出流         OutputStream
    B:字符流      字符输入流          Reader             字符输出流           Writer
  
    这四个都是抽象类
    输入流：读取数据
    输出流：写入数据
   (2)文件的写入数据
    对文本文件写入数据：
     Writer -- FileWriter
   
    FileWriter的构造方法：
     FileWriter(File file)
     FileWriter(String name)
     FileWriter(File file,boolean append)
     FileWriter(String name,boolean append)
  
    字符输出流写入数据的基本步骤：
     A:创建字符输出流对象
     B:调用该对象的write方法
     C:释放资源
  
    代码体现：
     FileWriter fw = new FileWriter("fw.txt");
  
     fw.write("hello,io");
     fw.flush();
  
     fw.close();
  
    问题：
     FileWriter fw = new FileWriter("fw.txt");做了哪些事情？
      创建了字符输出流对象
      把字符输出流对象指向了要写入数据的文件对象
      调用系统资源，创建文件对象(不管文件是否存在，都会创建)
  
     flush和close的区别？
      flush刷新缓冲区，close刷新缓冲区，并释放资源。
      flush刷新缓冲区后，流对象还可以继续使用，close释放资源后，
       流对象不能被使用。
  
     为什么流操作一定要调用close方法？
      创建字符输出流对象的时候：不仅仅是在堆内存创建了java对象，
      并且使用了系统资源创建了文件对象，当程序结束后，java的对象
      会自动变成垃圾，被回收。 而系统的资源就一直在被使用，所以，
      我们需要调用close方法，就是去通知系统，你创建文件时候使用的
      资源可以释放了。
  
    两个小知识点：
     如何追加数据，而不是覆盖数据？
      使用带两个参数的构造方法，第二个参数表示是否是追加数据，写为true即可。
  
     数据追加或者写入的时候，如何换行？
      换行在不同的操作系统中，对应的字符不一样：
      windows: \r\n
      linux: \n
  
      有些软件，对不同的换行都是识别的，比如：editplus
      但是，windows自带的记事本只能识别\r\n。
  
    加入异常处理：
     FileWriter fw = null;
     try
     {
      fw = new FileWriter("fw.txt");
  
      fw.write("haha");
      fw.flush();
     }
     catch(IOException e)
     {
      e.printStackTrace();
     }
     finally
     {
      if(fw!=null)
      {
       try
       {
        fw.close();
       }
       catch(IOException e)
       {
        e.printStackTrace();
       }
      }
     }
  
  
   (3)文件的读取数据
    对文本文件读取数据：
     Reader -- FileReader
   
    FileReader的构造方法：
     FileReader(File file)
     FileReader(String name)
  
    字符输入流读取数据的基本步骤：
     A:创建字符输入流对象
     B:调用该对象的read方法
     C:释放资源
  
    代码体现：
     
     一次读写一个字符代码如下：
     FileReader fr = new FileReader("fw.txt");
     
     //一次读写一个字符
     int num = 0;
     while((num=fr.read())!=-1)
     {
      System.out.print((char)num);
     }
  
     fr.close();
  
     一次读写一个字符数组代码如下：
     FileReader fr = new FileReader("fw.txt");
     
     //一次读写一个字符数组
     char[] chs = new char[1024]; //1024的整数倍
     int len = 0; //存储读取的实际长度
     while((len=fr.read(chs))!=-1)
     {
      System.out.print(new String(chs,0,len));
     }
  
     fr.close();
  
    加入异常处理：
     FileReader fr = null;
     try
     {
      fr = new FileReader("fw.txt");
  
      int num = 0;
      while((num=fr.read())!=-1)
      {
       System.out.print((char)num);
      }
     }
     catch(IOException e)
     {
      e.printStackTrace();
     }
     finally
     {
      if(fr!=null)
      {
       try
       {
        fr.close();
       }
       catch(IOException e)
       {
        e.printStackTrace();
       }
      }
     }
  
   (4)文件的复制
    数据源：
     来源：a.txt
     FileReader -- 读取数据
    目的地：
     目的：b.txt
     FileWriter -- 写入数据
  
    代码体现：
     方式1：每次读写一个字符
      
      FileReader fr = new FileReader("a.txt");
      FileWriter fw = new FileWriter("b.txt");
  
      
      int num = 0;
      while((num=fr.read())!=-1)
      {
       fw.write(num)
      }
  
      fw.close();
      fr.close();
  
     方式2：每次读写一个字符数组
      
      FileReader fr = new FileReader("a.txt");
      FileWriter fw = new FileWriter("b.txt");
  
      char[] chs = new char[1024];
      int len = 0;
      while((len=fr.read(chs))!=-1)
      {
       fw.write(chs,0,len);
       fw.flush();
      }
  
      fw.close();
      fr.close();
  2:带缓冲的字符流对象
   (1)字符流体系图
    Reader 的功能
     read()
     read(char[] chs)
     close()
     
     FileReader:没有特殊方法
     BufferReader:readLine()
  
    Writer  的功能
     write(int ch)
     write(String str)
     write(String str,int start,int end)
     write(char[] chs)
     write(char[] chs,int start,int end)
     flush()
     close()
     
     FileWriter:没有特殊方法
     BufferedWriter:newLine()
   (2)字符缓冲输出流写入数据
    代码体现：
  
     BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
  
     bw.write("哈哈");
     bw.newLine();
     bw.flush();
  
     bw.close();
  
   (3)字符缓冲输入流读取数据
    代码体现：
     
     方式1：
      BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
  
      int num = 0;
      while((num=br.read())!=-1)
      {
       System.out.print((char)num);
      }
  
      br.close();
  
     方式2：
      BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
  
      char[] chs = new char[1024];
      int len = 0;
      while((len=br.read(chs))!=-1)
      {
       System.out.print(new String(chs,0,len));
      }
  
      br.close();
     方式3：
      BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
  
      String line = null;
      while((line=br.readLine())!=null)
      {
       System.out.println(line);
      }
  
      br.close();
   
   (4)字符缓冲流复制文本文件
    代码体现:采用第三种方式读写，并加入异常处理。
  
     BufferedReader br = null;
     BufferedWriter bw = null;
     
     try
     {
      br = new BufferedReader(new FileReader("a.txt"));
      bw = new BufferedWriter(new FileWriter("b.txt"));
  
      String line = null;
      while((line=br.readLine())!=null)
      {
       bw.write(line);
       bw.newLine();
       bw.flush();
      }
     }
     catch(IOException e)
     {
      e.printStackTrace();
     }
     finally
     {
      if(bw!=null)
      {
       try
       {
        bw.close();
       }
       catch(IOException e)
       {
        e.printStackTrace();
       }
      }
  
      if(br!=null)
      {
       try
       {
        br.close();
       }
       catch(IOException e)
       {
        e.printStackTrace();
       }
      }
     }
     

值得学习ing!

还有后面的总结吗？