1. 基本介绍

1. 节点流可以从一个特定的数据源读写数据，如FileReader、FileWriter
   
2. 处理流(也叫包装流)是“连接”在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter
   

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

1. 节点流是底层流/低级流,直接跟数据源相接。
2. 处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。
3. 处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连[模拟修饰器设计模式=》小伙伴就会非常清楚.]

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

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

4. 处理流-BufferedReader和BufferedWriter

BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的关闭时处理流，只需要关闭外层流即可

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

import java.io.BufferedReader;
import java.io.FileReader;public class BufferedReader_ {public static void main(String[] args) throws Exception {String filePath = "e:\\a.java";//创建bufferedReaderBufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));//读取String line; //按行读取, 效率高//说明//1. bufferedReader.readLine() 是按行读取文件//2. 当返回null 时，表示文件读取完毕while ((line = bufferedReader.readLine()) != null) {System.out.println(line);}//关闭流, 这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭 节点流FileReader。bufferedReader.close();}
}

2. 使用BufferedWriter将“hello”写入到文件中

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;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("hello1!");bufferedWriter.newLine();//插入一个和系统相关的换行bufferedWriter.write("hello2!");bufferedWriter.newLine();bufferedWriter.write("hello3!");bufferedWriter.newLine();//说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭bufferedWriter.close();}
}

3. 综合使用BufferedReader和BufferedWriter完成文本文件拷贝

import java.io.*;public class BufferedCopy_ {public static void main(String[] args) {//1. BufferedReader 和 BufferedWriter 是安装字符操作//2. 不要去操作 二进制文件[声音，视频，doc, pdf ], 可能造成文件损坏String srcFilePath = "e:\\a.java";String destFilePath = "e:\\a2.java";
//        String srcFilePath = "e:\\0245.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();}}}
}

5. 处理流-BufferedInputStreamBufferedOutputStream

BufferedlnputStream是字节流在创建 BufferedInputStream时，会创建一个内部缓冲区数组.
BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

import java.io.*;/*** 使用BufferedOutputStream 和 BufferedInputStream使用* 使用他们，可以完成二进制文件拷贝.* 字节流可以操作二进制文件，可以操作文本文件吗？当然可以*/
public class BufferedCopy02 {public static void main(String[] args) {String srcFilePath = "e:\\Koala.jpg";String destFilePath = "e:\\Koala2.jpg";
//        String srcFilePath = "e:\\Koala.avi";
//        String destFilePath = "e:\\Koala2.avi";
//        String srcFilePath = "e:\\a.java";
//        String destFilePath = "e:\\a2.java";//创建BufferedOutputStream对象BufferedInputStream对象BufferedInputStream bis = null;BufferedOutputStream bos = null;try {//因为 FileInputStream  是 InputStream 子类bis = new BufferedInputStream(new FileInputStream(srcFilePath));bos = new BufferedOutputStream(new FileOutputStream(destFilePath));//循环的读取文件，并写入到 destFilePathbyte[] buff = new byte[1024];int readLen = 0;//当返回 -1 时，就表示文件读取完毕while ((readLen = bis.read(buff)) != -1) {bos.write(buff, 0, readLen);}System.out.println("文件拷贝完毕~~~");} catch (IOException e) {e.printStackTrace();} finally {//关闭流 , 关闭外层的处理流即可，底层会去关闭节点流try {if(bis != null) {bis.close();}if(bos != null) {bos.close();}} catch (IOException e) {e.printStackTrace();}}}
}

6. 对象流-ObjectInputStream和ObjectOutputStream

看一个需求
1.将int num = 100 这个int数据保存到文件中，注意不是100 数字，而是int100，并且，能够从文件中直接恢复int 100
2. 将Dog dog = new Dog(“小黄”，3) 这个 dog对象 保存到 文件中，并且能够从文件恢复.
3.上面的要求，就是能够将基本数据类型 或者 对象 进行 序列化和 反序列化操作

序列化和反序列化

1. 序列化就是在保存数据时，保存数据的值和数据类型
2. 反序列化就是在恢复数据时，恢复数据的值和数据类型
3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:
   Serializable // 这是一个标记接口,没有方法
   Externalizable //该接口有方法需要实现，因此我们一般实现上面的Serializable接口

对象流提供了对基本类型或对象类型的序列化和反序列化的方法
ObjectOutputStream提供序列化功能
ObjectInputStream提供反序列化功能

注意事项和细节说明

1. 读写顺序要一致
2. 要求序列化或反序列化对象，需要实现Serializable
3. 序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
4. 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
5. 序列化对象时，要求里面属性的类型也需要实现序列化接口
6. 序列化具备可继承性,也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

ObjectOutputStream实例

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;/*** 使用ObjectOutputStream, 完成数据的序列化*/
public class ObjectOutStream_ {public static void main(String[] args) throws Exception {//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存String filePath = "e:\\data.dat";ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));//序列化数据到 e:\data.datoos.writeInt(100);// int -> Integer (实现了 Serializable)oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)oos.writeChar('a');// char -> Character (实现了 Serializable)oos.writeDouble(9.5);// double -> Double (实现了 Serializable)oos.writeUTF("韩顺平教育");//String//保存一个dog对象oos.writeObject(new Dog("旺财", 10, "日本", "白色"));oos.close();System.out.println("数据保存完毕(序列化形式)");}
}

import java.io.Serializable;//如果需要序列化某个类的对象，实现 Serializable
public class Dog implements Serializable {private String name;private int age;//序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员private static String nation;private transient String color;//序列化对象时，要求里面属性的类型也需要实现序列化接口private Master master = new Master();//serialVersionUID 序列化的版本号，可以提高兼容性private static final long serialVersionUID = 1L;public Dog(String name, int age, String nation, String color) {this.name = name;this.age = age;this.color = color;this.nation = nation;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}' + nation + " " +master;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

ObjectInputStream实例

import com.outputstream_.Dog;
import java.io.*;public class ObjectInputStream_ {public static void main(String[] args) throws IOException, ClassNotFoundException {//指定反序列化的文件String filePath = "e:\\data.dat";ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));//读取//1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致，否则会出现异常System.out.println(ois.readInt());System.out.println(ois.readBoolean());System.out.println(ois.readChar());System.out.println(ois.readDouble());System.out.println(ois.readUTF());//dog 的编译类型是 Object , dog 的运行类型是 DogObject dog = ois.readObject();System.out.println("运行类型=" + dog.getClass());System.out.println("dog信息=" + dog);//底层 Object -> Dog//特别重要的细节://1. 如果我们希望调用Dog的方法, 需要向下转型//2. 需要我们将Dog类的定义，放在到可以引用的位置Dog dog2 = (Dog)dog;System.out.println(dog2.getName()); //旺财..//关闭流, 关闭外层流即可，底层会关闭 FileInputStream 流ois.close();}
}