1. 节点流是底层流/低级流，直接跟数据源相接
2. 处理流（包装流）包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出
3. 处理流（也叫包装流）对节点流进行包装，使用了修饰器设计模式，不会直接与数据源连接

1. 性能的提高：主要以增加缓冲的方式来提高输入输出的效率
2. 操作的便捷：处理流可以提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便。

package com.jshedu.moshi;

/**
 * @author Mr.jia
 * @version 1.0
 */

public abstract class Reader_ {//抽象类
    public void readFile(){};
    public void readString(){};
    //都继承Reader_,关键BufferedReader_里有一个private Reader_ reader_;属性
    //然后通过BufferedReader_里的方法调用Reader_子类的实现方法。
    //称为包装流


}
//包装流
class BufferedReader_ extends Reader_{
    //继承了Reader_,它里面的方法也能用了
    private Reader_ reader_;//属性是Reader_类型


    public BufferedReader_(Reader_ reader_) {
        //这个构造器参数可以接受Reader_类型，也可以接收其子类
        this.reader_ = reader_;
    }
    public void readFile(){//封装一层
        reader_.readFile();
    }
    //让方法更灵活，多次读取文件
    public void readFiles(int num){
        for (int i = 0; i < num; i++) {
            reader_.readFile();
        }
    }
    //扩展readString，批量处理字符串数据
    public void readStrings(int num){
        for (int i = 0; i < num; i++) {
            reader_.readString();
        }
    }
}
//节点流
class FileReader_ extends Reader_{
    public void readFile(){
        System.out.println("对文件进行读取...");
    }
}
//节点流
class StringReader_ extends Reader_{
    public void readString(){
        System.out.println("读取字符串...");
    }
}

package com.jshedu.moshi;

/**
 * @author Mr.jia
 * @version 1.0
 */

public class Test_ {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
        bufferedReader_.readFiles(10);
        bufferedReader_.readFile();//这里也可以吊起来了
        //因为在BufferedReader_类里写了什么才能调什么
        BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
        bufferedReader_1.readStrings(5);
    }
}

都继承Reader_,关键BufferedReader_里有一个private Reader_ reader_;属性
然后通过BufferedReader_里的方法调用Reader_子类的实现方法。
称为包装流

package com.hspedu.reader_;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示bufferedReader 使用
 */
public class BufferedReader_ {
    public static void main(String[] args) throws Exception {

        String filePath = "e:\\a.java";
        //创建bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line; //按行读取, 效率高
        //说明
        //1. bufferedReader.readLine() 是按行读取文件
        //2. 当返回null 时，表示文件读取完毕
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }

        //关闭流, 这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭 节点流
        //FileReader。
        /*
            public void close() throws IOException {
                synchronized (lock) {
                    if (in == null)
                        return;
                    try {
                        in.close();//in 就是我们传入的 new FileReader(filePath), 关闭了.
                    } finally {
                        in = null;
                        cb = null;
                    }
                }
            }

         */
        bufferedReader.close();

    }
}

BufferedReader的使用

package com.hspedu.writer_;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示BufferedWriter的使用
 */
public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\\ok.txt";
        //创建BufferedWriter
        //说明:
        //1. new FileWriter(filePath, true) 表示以追加的方式写入
        //2. new FileWriter(filePath) , 表示以覆盖的方式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("hello, 韩顺平教育!");
        bufferedWriter.newLine();//插入一个和系统相关的换行
        bufferedWriter.write("hello2, 韩顺平教育!");
        bufferedWriter.newLine();
        bufferedWriter.write("hello3, 韩顺平教育!");
        bufferedWriter.newLine();

        //说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭
        bufferedWriter.close();

    }
}

演示BufferedWriter的使用

package com.hspedu.writer_;

import java.io.*;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class BufferedCopy_ {

    public static void main(String[] args) {


        //老韩说明
        //1. BufferedReader 和 BufferedWriter 是安装字符操作
        //2. 不要去操作 二进制文件[声音，视频，doc, pdf ], 可能造成文件损坏
        //BufferedInputStream
        //BufferedOutputStream
        String srcFilePath = "e:\\a.java";
        String destFilePath = "e:\\a2.java";
//        String srcFilePath = "e:\\0245_韩顺平零基础学Java_引出this.avi";
//        String destFilePath = "e:\\a2韩顺平.avi";
        BufferedReader br = null;
        BufferedWriter bw = null;
        String line;
        try {
            br = new BufferedReader(new FileReader(srcFilePath));
            bw = new BufferedWriter(new FileWriter(destFilePath));

            //说明: readLine 读取一行内容，但是没有换行
            while ((line = br.readLine()) != null) {
                //每读取一行，就写入
                bw.write(line);
                //插入一个换行
                bw.newLine();
            }
            System.out.println("拷贝完毕...");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if(br != null) {
                    br.close();
                }
                if(bw != null) {
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

Buffered字符处理流Copy