java IO流（终）缓冲流与序列化

缓冲流：

缓冲流也叫高效流。再创建流对象时，会创建一个内置默认大小的缓冲区数组，通过缓冲区读写来减少系统IO次数，从而提高读写效率。

字节缓冲流

不使用缓冲流

 long start=System.currentTimeMillis();
        //创建流对象
        FileInputStream fileInputStream=new FileInputStream("0.png");
        FileOutputStream fileOutputStream=new FileOutputStream("0copy.png");
        //读取0.png内容并复制
        int a;
        while ((a=fileInputStream.read())!=-1){

            fileOutputStream.write(a);
        }
        //关闭流
       fileInputStream.close();
        fileOutputStream.close();
        long end=System.currentTimeMillis();
        System.out.println("复制所花的时间"+(end-start)+"毫秒");
    }

使用缓冲池

  long start=System.currentTimeMillis();
        //创建流对象
        FileInputStream fileInputStream=new FileInputStream("0.png");
        //两种创建方式
        //第一种创建输入流
        BufferedInputStream bufferedInputStream=new BufferedInputStream(fileInputStream);
        //第二中创建输出流
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream("0copy.png"));
        //读取0.png内容并复制
        int a;
        while ((a=bufferedInputStream.read())!=-1){

            bufferedOutputStream.write(a);
        }
        //关闭流
        bufferedInputStream.close();
        bufferedOutputStream.close();
        long end=System.currentTimeMillis();
        System.out.println("复制所花的时间"+(end-start)+"毫秒");
    }

使用缓冲池可以提高大幅提高读写效率。

字符缓冲池：

readLine方法演示：

  FileReader fileReader=new FileReader("b.txt");
        BufferedReader reader=new BufferedReader(fileReader);
        String line;
        //readLine()读取一行
        while ((line=reader.readLine())!=null){
            System.out.println(line);
        }
        //释放资源
        reader.close();

    }

newLine() 方法演示：

public static void main(String[] args) throws IOException {
        //创建流对象
        BufferedWriter writer=new BufferedWriter(new FileWriter("b.txt"));
        writer.write("你好啊");
        //换行
        writer.newLine();
        writer.write("你也好啊");
        writer.close();
    }

看一下b.txt的内容

序列化：

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读 写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序 列 化 的 实 现 ： 将 需 要 被 序 列 化 的 类 实 现 Serializable 接 口 ， 该 接 口 没 有 需 要 实 现 的 方 法 ， implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造 一个 ObjectOutputStream(对象流)对象，接着，使用 ObjectOutputStream 对象的 writeObject(Object obj)方法就 可以将参数为 obj 的对象写出(即保存其状态)，要恢复的话则用输入流。

student对象：

public class Student implements Serializable {
    //加入序列版本号
    public static final   long serialVersionUID =1L;
    private  String name;
    private transient int age; //瞬态修饰，不会被序列化

    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;
    }

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

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

序列化与反序列化实现：

 public static void main(String[] args) throws IOException, ClassNotFoundException {
        Student student=new Student();
        student.setName("lu");
        student.setAge(20);
        //创建序列化对象
        ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream("student.txt"));
        //写出对象
        out.writeObject(student);
        //释放资源
        out.close();
        //创建反序列化对象
        FileInputStream fis=new FileInputStream("student.txt");
        ObjectInputStream objectInputStream=new ObjectInputStream(fis);
        Object s1= objectInputStream.readObject();
        //输出对象
        System.out.println(s1);
        //释放资源
        objectInputStream.close();

    }

输出结果：

 由于age被瞬态修饰，所以不会被序列化。