IO流(一)

内容概要：

Java以流的形式处理所有输入和输出。流是随通信路径从源移动到目的地的字节序列。

内存与存储设备之间传输数据的通道

流的分类：

按方向

输入流：将存储空间中的内容读到内存中   硬盘-->内存   外部源-->程序

输出流：将内存中的内容写到存储设备中

按单位

字节流：以字节为单位，可以读写所有数据

字符流：以字符为单位，只能读写文本数据

按功能

节点流：具有实际传输数据的读写功能

过滤流：在节点流的基础之上增强功能

缓冲流

缓冲输入流

可以说没有定义缓冲流时，我在进行输入流时，就像拿着灌满水的水杯往缸里装水，定义缓冲区后，我就先将杯子里的水装进水桶里，待水桶装满，再将水桶中的水往缸里倒。

减少往缸里运水的次数，从而提高效率

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

//BufferedInputStream
public class Demo03 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("d:\\1764\\aaa.txt");
        //BufferedInputStream bis = new BufferedInputStream(fis);
//定义缓冲区
        /*int data = 0;
        while ((data = bis.read()) != -1){
            System.out.print((char)data);
        }*/
        //自定义缓冲区
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = fis.read(buf)) != -1){
            System.out.println(new String(buf,0,count));
        }
        bis.close();//只需关闭缓冲输入流，输入流也会跟着关闭
    }
}

缓冲输出流

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

//字节输出缓冲流
public class Demo04 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("d:\\1764\\aaa.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        int count = 0;
        for (int i = 0; i < 10; i++) {
            bos.write("helloworld\n".getBytes());//写入缓冲区
            bos.flush();//刷新到硬盘，如果没有写，当断电时，会出现没有写到硬盘上的问题，导致数据丢失；在write中当缓冲区满时，会自动调用flushBuffer方法写出
        }
        bos.close();//关闭的时候内部也会调用flush方法
        System.out.println("打印结束");
    }
}

一  什么叫序列化

通俗点讲：它是处理对象流的一种机制，即可以很方便的保存内存中java对象的状态，同时也为了方便传输。

二 序列化有什么作用

1.方便传输，速度快，还很安全，被调用方序列化，调用方反序列化即可拿到传输前最原始的java对象，常用于不同进程之间的对象传输

2.方便存储，不管是存储成文件还是数据库，都行，存储为文件，下回要用可以直接反序列拿到对象

三 怎么序列化和反序列化

实现序列化接口就行（里面什么方法都没有，不用管的，只是一个标记接口而已）Serializable；

至于他们的代码怎么写，网上例子很多，随便搜一下就行了

//ObjectOutputStream实现对象的序列化
  Student

//序列化类必须实现Serializable接口

//标志可以进行序列化

import java.io.*;
//序列化类必须实现Serializable接口
class Student implements Serializable {  //标志可以进行序列化
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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 +
                '}';
    }
}
//ObjectOutputStream实现对象的序列化
public class Demo05 {
    public static void main(String[] args) throws IOException {
        //创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\1764\\aaa.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //进行序列化(写入操作)
        Student s1 = new Student("张三",20);
        oos.writeObject(s1);

        oos.close();
        System.out.println("序列化完毕");
    }
}

//使用ObjectInputStream实现反序列化(读取重构成对象)

//使用ObjectInputStream实现反序列化(读取重构成对象)

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;public class Demo06 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建对象流
        FileInputStream fis = new FileInputStream("d:\\1764\\aaa.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //读取文件(反序列化)
        Student s = (Student) ois.readObject();

        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

关于序列化类

import java.io.*;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.LinkedList;
//1.序列化类必须要实现Serializable接口
//2.序列化类中对象属性要求实现Serializable接口
//3.序列化版本号ID serialVersionUID,保证序列化的类和反序列化的类是同一个类
//4.使用transient(瞬间的) 修饰属性,这个属性不能序列化
//5.静态属性不能序列化
//6.序列化多个对象,可以借助集合实现
//ObjectOutputStream实现对象的序列化
public class Demo05 {
    public static void main(String[] args) throws IOException {
        //创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\1764\\aaa.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //进行序列化(写入操作)
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",18);
        ArrayList<Student> list = new ArrayList<>();
        list.add(s1);
        list.add(s2);
        oos.writeObject(list);

        oos.close();
        System.out.println("序列化完毕");
    }
}

then  ObjectInputStream

//使用ObjectInputStream实现反序列化(读取重构成对象)

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.ArrayList;

public class Demo06 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建对象流
//        new String();//ctrl shift alt u
        FileInputStream fis = new FileInputStream("d:\\1764\\aaa.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //读取文件(反序列化)
//        Student s = (Student) ois.readObject();
//        Student s1 = (Student) ois.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        ois.close();
        System.out.println("执行完毕");
        System.out.println(list.toString());

    }

}