/
    一、流的分类：
     1.操作数据单位：字节流、字符流
    2.数据的流向：输入流、输出流
     3.流的角色：节点流、处理流


     二、流的体系结构
    抽象基类 节点流（或文件流） 缓冲流（处理流的一种）
     InputStream FileInputStream （read(byte[] buffer) ） BufferedFileInputStream
    OutputStream FileOutputStream （write(byte[] buffer,0,len)） BufferedFileOutputStream
     Reader FileReader （read(char[] buff)） BufferedFileReader
    Writer FileWriter （write(char[] buff,0,len)） BufferedFileWriter

    *
    flush()是一个缓冲流的刷新方法

    三、操作步骤：
    //1.实例化File类的对象，指明要操作的文件
    //2.提供具体的流
    //3.数据的读入
    //4.流的关闭操作

    1. package com.atguigu.java1;
    3. import org.junit.Test;
    5. import java.io.File;
    6. import java.io.FileReader;
    7. import java.io.FileWriter;
    8. import java.io.IOException;
    10. /**
    11.  * 一、流的分类：
    12.  * 1.操作数据单位：字节流、字符流
    13.  * 2.数据的流向：输入流、输出流
    14.  * 3.流的角色：节点流、处理流
    15.  * <p>
    16.  * 二、流的体系结构
    17.  * 抽象基类               节点流（或文件流）             缓冲流（处理流的一种）
    18.  * InputStream             FileInputStream              BufferedFileInputStream
    19.  * OutputStream            FileOutputStream             BufferedFileOutputStream
    20.  * Reader                  FileReader                   BufferedFileReader
    21.  * Writer                  FileWriter                   BufferedFileWriter
    22.  *
    23.  * @author Dxkstart
    24.  * @create 2021-05-29 15:54
    25.  */
    26. public class FileReaderWriterTest {
    28.     /*
    29.     将day09下的HelloWorld.txt文件的内容读入程序中，并输出到控制台
    31.     说明点：
    32.     1.read()理解：返回读入的一个字符。如果达到文件末尾，返回-1
    33.     2.异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
    34.     3.读入的文件一定要存在，否则就会报FileNotFoundException.
    36.      */
    37.     @Test
    38.     public void test1() {
    39.         FileReader fileReader = null;
    41.         try {
    42.             //1.实例化File类的对象，指明要操作的文件
    43.             File file = new File("HelloWorld.txt");
    45.             //2.提供具体的流
    46.             fileReader = new FileReader(file);
    48.             //3.数据的读入
    49.             //read():返回读入的一个字符。如果达到文件的末尾，返回-1
    51.             //方式一：
    52. //        int read = fileReader.read();
    53. //        while(read != -1){
    54. //            System.out.print((char)read);
    55. //            read = fileReader.read();
    56. //        }
    58.             //方式二：语法上对方式一修改
    59.             int data;
    60.             while ((data = fileReader.read()) != -1) {
    61.                 System.out.print((char) data);
    62.             }
    64.         } catch (IOException e) {
    65.             e.printStackTrace();
    67.         } finally {
    69.             try {
    70.                 //4.流的关闭操作
    71.                 if (fileReader != null) {
    72.                     fileReader.close();
    73.                 }
    74.             } catch (IOException e) {
    75.                 e.printStackTrace();
    76.             }
    77.         }
    79.     }
    82.     //对read()操作升级：使用read的重载方法
    83.     @Test
    84.     public void test2_FileReader1() {
    85.         FileReader fr = null;
    87.         try {
    88.             //1.File类的实例化
    89.             File file = new File("HelloWorld.txt");
    92.             //2.流的实例化（如：FileReader流）
    93.             fr = new FileReader(file);
    95.             //3.读入的操作
    96.             //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
    97.             char[] cbuf = new char[5];
    98.             int len;
    99.             while ((len = fr.read(cbuf)) != -1) {
    100.                 //错误的写法
    101. //                for(int i = 0;i < cbuf.length;i++){
    102. //                    System.out.print(cbuf[i]);
    103. //                }
    104.                 //正确写法
    105. //                for(int i = 0;i < len;i++){
    106. //                    System.out.print(cbuf[i]);
    107. //                }
    109.                 //错误的写法
    110. //                String str = new String(cbuf);
    111. //                System.out.print(str);
    113.                 //正确写法
    114.                 String str = new String(cbuf, 0, len);
    115.                 System.out.print(str);
    117.             }
    118.         } catch (IOException e) {
    119.             e.printStackTrace();
    120.         } finally {
    121.             try {
    122.                 //4.资源的关闭（流的关闭，close()）
    123.                 if(fr != null) {
    124.                     fr.close();
    125.                 }
    126.             } catch (IOException e) {
    127.                 e.printStackTrace();
    128.             }
    130.         }
    132.     }
    135.     /*
    136.     从内存中写出数据到硬盘的文件里。
    138.     说明：
    139.     1. 输出操作，对应的File可以不存在的。并不会报错
    141.     2. File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
    142.        File对应的硬盘中的文件如果存在：
    143.               如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
    144.               如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是追加内容
    148.      */
    149.     @Test
    150.     public void test_FileWriter() {
    151.         FileWriter fw = null;
    153.         try {
    154.             //1.提供File类的对象，指明写出到的文件
    155.             File file = new File("Hello1.txt");
    157.             //2.提供FileWriter的对象，用于数据的写出
    158.             fw = new FileWriter(file,true);
    160.             //3.写出操作
    161.             fw.write("I hava a dream!\n");
    162.             fw.write("You need to have a dream!\n");
    163.         } catch (IOException e) {
    164.             e.printStackTrace();
    165.         } finally {
    166.             try {
    167.                 //4.流的关闭
    168.                 if(fw != null){
    169.                     fw.close();
    170.                 }
    171.             } catch (IOException e) {
    172.                 e.printStackTrace();
    173.             }
    175.         }
    176.     }
    179.     @Test
    180.     public void test_FileReader_FileWriter(){
    181.         FileReader fr = null;
    182.         FileWriter fw = null;
    184.         try {
    185.             //1.创建File的对象，指明读入和写出的文件
    186.             File readfile = new File("Hello1.txt");
    187.             File writfile = new File("hello2.txt");
    189.             //2.创建输入流和输出流的对象
    190.             fr = new FileReader(readfile);
    191.             fw = new FileWriter(writfile);
    193.             //3.数据的读入和写出操作
    194.             char[] cbuf = new char[5];
    195.             int len;//记录每次读入到cbuf数组中的字符的个数
    196.             while((len = fr.read(cbuf)) != -1) {
    197.                 //每次写出len个字符
    198.                 fw.write(cbuf,0,len);
    200.             }
    201.         } catch (IOException e) {
    202.             e.printStackTrace();
    203.         } finally {
    204.             //4.关闭流资源
    205.             try {
    206.                 if(fw != null)
    207.                     fw.close();
    208.             } catch (IOException e) {
    209.                 e.printStackTrace();
    210.             }
    212.             try {
    213.                 if(fr != null)
    214.                 fr.close();
    215.             } catch (IOException e) {
    216.                 e.printStackTrace();
    217.             }
    218.         }
    223.     }
    225. }