处理流与其实现类

节点流

节点流可以从一个特定的数据源读写程序，比如FileReader等

处理流

处理流（包装流）是连接已经存在的流（节点流或处理流之上），为程序提供更加强大的读写功能，比如BufferedReader、BufferedWriter

上面含有一个Reader，可以对节点流进行包装，只要是reader的子类即可，对文件，数组，数据源等都可以进行相应的操作，关闭处理流的时候只需要关闭处理流即可，处理流调用节点流的close，自动关闭。如果想要以追加的方式写入，只需要在节点流哪里true即可，尽量不要使用该方法操作二进制文件，会造成文件损毁。

字节处理流

BufferReader

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author zss
 */
public class Test {
    public static void main(String[] args) throws IOException {
        String filePath="D:\\壁纸\\hello.txt";
        BufferedReader bufferedReader=null;
        try {
            bufferedReader = new BufferedReader(new FileReader(filePath));
            /*按行读取*/
            String line;

            /*当返回空时，结束读取*/
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
        }catch (IOException ioException){
            ioException.printStackTrace();
        }finally {
            bufferedReader.close();
        }
    }


}

BufferWriter

import java.io.*;

/**
 * @author zss
 */
public class Test {
    public static void main(String[] args) throws IOException {
        String filePath="D:\\壁纸\\hello.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("你好啊");
        //换行
        bufferedWriter.newLine();
        bufferedWriter.write("你好啊");
        bufferedWriter.close();
    }
}

练习

import java.io.*;

/**
 * @author zss
 */
public class Test {
    public static void main(String[] args) throws IOException {
        String filePath="D:\\壁纸\\hello.txt";
        String filePath1="D:\\文件下载\\hello.txt";
        BufferedReader bufferedReader=new BufferedReader(new FileReader(filePath));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath1));
        String line;
        while ((line=bufferedReader.readLine())!=null){
            bufferedWriter.write(line);
            bufferedWriter.newLine();
        }
        bufferedReader.close();
        bufferedWriter.close();
    }
}

字节处理流

BufferInputStream，BufferOutputStream

拷贝二进制的图片

import java.io.*;

/**
 * @author zss
 */
public class Test {
    public static void main(String[] args) throws IOException {
        String filePath="D:\\壁纸\\彩云.png";
        String filePath1="D:\\文件下载\\彩云.png";
        BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream(filePath));
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(filePath1));
        int flag;
        while ((flag=bufferedInputStream.read())!=-1){
            bufferedOutputStream.write(flag);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}

对象处理流

比如保存int 100，而不是仅仅保存100这个数据，或者可以保存这个对象以及其相应的数据类型

序列化和反序列化

1. 序列化就是在保存数据时，保存数据的值和数据类型
2. 反序列化就是在恢复数据的时候，回复数据的值和数据类型
3. 需要将某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下的两个接口之一：Serializable或者Externalizable（该接口有方法需要实现）

ObjectInputStream（序列化）

import java.io.*;

/**
 * @author zss
 */
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("D:\\文件下载\\test.dat"));
        //反序列化的顺序要和序列化的顺序一致
       System.out.println(objectInputStream.readInt());
       System.out.println(objectInputStream.readUTF());
       Object dog=objectInputStream.readObject();
       System.out.println(dog);
       objectInputStream.close();

    }
}
class Dog implements Serializable{
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //如果想要输出真是的信息，则应该在序列化时就定义了tostring，当然如果我们想要调用dog的方法，则向下转型，这是需要见dog的定义可以引用到序列化的文件，而且对象的包也必须在同一个文件夹，否则我们存储的类就无法进行转换

    /*@Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }*/
}

ObjectOuputStream（反序列化）

import java.io.*;

/**
 * @author zss
 */
public class Excesice {
    public static void main(String[] args) throws IOException {
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("D:\\文件下载\\test.dat"));

        /*下面的方法中调用的包装类，Integer等，本身就已经继承了Serializable接口*/
        objectOutputStream.writeInt(1);
        objectOutputStream.writeUTF("你好");

        objectOutputStream.writeObject(new Dog("旺财",99));
        objectOutputStream.close();
    }
}
class Dog implements Serializable{
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

注意：序列化的时候，默认将所有的属性都进行了序列化，但是除了static或者transient修饰的成员。而进行序列化对象的时候，，要求属性里面的所有都实现序列化，继承接口。