节点流和处理流一

1. 基本介绍  621

1.节点流可以从一个特定的数据源读写数据，如FileReader、 FileWriter [源码]

2.处理流(也叫包装流)是"连接”在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter [源码]

2. 节点流和处理流一览图  621

3. 节点流和处理流的区别和联系  622

1. 节点流是底层流/低级流，直接跟数据源相接。

2. 处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。[源码理解]

3. 处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连[模拟修饰器设计模式=》小伙伴就会非常清楚.]

3.1 模拟处理流

代码在com.stulzl.reader_.包中

测试Test_

package com.stulzl.reader_;

//模拟处理流/包装流  622
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_ 

package com.stulzl.reader_;

public abstract class Reader_ {//抽象类
    //定义两个方法
    public void readFile() {};
    public void readString(){};
}

子类BufferedReader_

package com.stulzl.reader_;

//模拟处理流/包装流  622
public class BufferedReader_ extends Reader_{//看作包装流

    private Reader_ reader_;//直接定义一个抽象类Reader_类型的属性

    //构造器，可以根据传进来的对象参数，去动态绑定相应的类的方法 //涉及多态和动态绑定
    public BufferedReader_(Reader_ reader_) {//可以接收Reader_子类对象
        this.reader_ = reader_;
    }

    //调用最底层的(子类)readFile()方法
    public void readFile() { //封装一层
        reader_.readFile();
    }

    //提供方法 让方法更加灵活，多次读取文件
    public void readFiles(int num){
        //循环调用方法
        for (int i = 0; i < num; i++) {
            //因为reader_是抽象类，其他类继承并实现了其中的方法，所以可以调用
            //涉及多态和动态绑定
            reader_.readFile();//调用Reader_中的readFile()
        }
    }

    //扩展 readString, 批量处理字符串数据
    public void readStrings(int num) {
        for(int i = 0; i <num; i++) {
            reader_.readString();
        }
    }

}

子类FileReader_

package com.stulzl.reader_;

public class FileReader_ extends Reader_{//看做节点流
    //实现抽象类中的方法
    public void readFile(){
        System.out.println("对文件进行操作……");
    }
}

子类StringReader_

package com.stulzl.reader_;

public class StringReader_ extends Reader_{//看做节点流
    //实现抽象类中的方法
    public void readString(){
        System.out.println("读取字符串……");
    }
}

4. 处理流的功能主要体现在以下两个方面:  623

1. 性能的提高:主要以增加缓冲的方式来提高输入输出的效率。

2. 操作的便捷:处理流可能提供了一系列便捷的方法来一 次输入输出大批量的数据，使用更加灵活方便

5. 处理流BufferedReader 和 BufferedWriter  623

➢BufferedReader 和BufferedWriter属于字符流，是按照字符来读取数据的

➢关闭时处理流，只需要关闭外层流即可

5.1 案例演示  BufferedReader   623

使用BufferedReader读取文本文件，并显示在控制台

代码在com.stulzl.bufferedreader_.包中

BufferedReader_

package com.stulzl.bufferedreader_;

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

//演示BufferedReader的使用  623
//使用BufferedReader读取文本文件，并显示在控制台
public class BufferedReader_ {
    public static void main(String[] args) throws Exception {
        String filePath = "e:\\story.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line;//用来接收readLine()的返回值
        //说明
        //1. bufferedReader.readLine() 是按行读取文件
        //2. 当返回 null 时，表示文件读取完毕
        while((line = bufferedReader.readLine())!=null){
            System.out.println(line);
        }
        //关闭流
        //这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭 节点流
        bufferedReader.close();
    }
}

5.2 案例演示BufferedWriter  624

使用BufferedWriter 将”hello,世界中国”，写入到文件中

代码在com.stulzl.bufferedwriter_.包中

BufferedWriter_

package com.stulzl.bufferedwriter_;

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

//案例演示BufferedWriter  624
//使用BufferedWriter 将”hello,世界中国”，写入到文件中
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 bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));

        bufferedWriter.write("hello,世界中国");//写一个字符串
        bufferedWriter.newLine();//插入一个和系统相关的换行符
        bufferedWriter.write("hello2,世界中国");
        bufferedWriter.newLine();
        bufferedWriter.write("hello3,世界中国");
        bufferedWriter.newLine();

        //关闭流
        bufferedWriter.close();
    }
}

5.3BufferedReader 和 BufferedWriter结合完成 拷贝案例  625

代码在com.stulzl.buffered_copy.包中

BufferedCopy_

package com.stulzl.buffered_copy;

import java.io.*;

//BufferedReader 和 BufferedWriter结合完成 拷贝案例  625
public class BufferedCopy_ {
    public static void main(String[] args) {
        //老韩说明
        //1. BufferedReader 和 BufferedWriter 是安照字符操作
        //2. 不要去操作 二进制文件[声音，视频，doc, pdf ], 可能造成文件损坏
        
        String srcFilePath = "e:\\story.txt";
        String destFilePath = "e:\\story2.txt";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        String line;
        try {
            bufferedReader = new BufferedReader(new FileReader(srcFilePath));
            bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));

            //读取
            while((line=bufferedReader.readLine())!=null){
                //每读一行写一行
                bufferedWriter.write(line);
                //换行
                bufferedWriter.newLine();
            }
            System.out.println("拷贝完毕……");

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