杰神之Java缓冲流和序列化的用法

缓冲流

1：定义：在内存与硬盘之间创建一个大小合适的缓冲区，当内存和硬盘进行数据访问时，能提高访问硬盘的次数，提高效率。
2：分类：缓冲分为字节缓冲流（BufferedInputStream和BufferedOutputStream）和字符缓冲流(BufferedReader和BufferedWrite)。
3：缓冲流对字节文件拷贝的效率测试：

/*
 * 测试高效流复制文件的快慢
 */
public class Demo02 {
    public static void main(String[] args) throws IOException {
        //测试
        new MyCopy2().printtime();;
    }
}

abstract class TestTime{
    public String src = "/Users/lanou/Desktop/Test/dp.png";
    public String dest = "/Users/lanou/Desktop/Test/dp01.png";
    public void printtime() throws IOException {
        long start = System.currentTimeMillis();
        //调用方法
        copyFile();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    // 子类要抛异常 父类就必须有这个异常
    public abstract void copyFile() throws IOException;
}

//实现类
class MyCopy1 extends TestTime{
    // 字节流 单个字节形式   复制文件
    //          数组形式      复制文件
    // 缓冲流 单个字节形式   复制文件
    //          数组形式      复制文件
    @Override
    public void copyFile() throws IOException {
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = new FileOutputStream(dest);
        int len = 0;
        byte[] b = new byte[1024];
        while ((len = fis.read(b)) != -1) {
            fos.write(b, 0, len);
        }
        fis.close();
        fos.close();
    }
}
class MyCopy2 extends TestTime{
    @Override
    public void copyFile() throws IOException {
        FileInputStream fis = new FileInputStream(src);
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream(dest);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        int len = 0;
        byte[] b = new byte[1024];
        while ((len = bis.read(b)) != -1) {
            bos.write(b, 0, len);
        }
        bis.close();
        bos.close();

    }
}

4：缓冲流属于包装流，只能对已有的流进行包装，使原来的流更加强大，执行效率更高，不能关联文件。
流总结

 * 1.明确 数据源 和 数据目的地 (要操作什么)
 *  读数据源: InputStream  Reader
 *  写到数据目的地: OutputStream Writer
 * 2. 明确要操作的是什么内容
 * 文本 音频 图片 ...使用字节流(全能流)
 * 文本(按编码格式读写) 使用字符流
 * 3.明确流要在什么设备上使用
 * 文本
 * 网络 通过流进行数据交互---字节流
 * 4.是否需要提高效率
 * BUffered 缓冲流

序列化

 * 序列化流与反序列化流
 * 序列化 把对象写进文件中
 * 反序列化 从文件中把对象读取出来
 * 
 * 对象流
 * ObjectInputStream
 * ObjectOutputStream
 * 
 * 注意: 静态成员变量 是不能进行序列化的
 * 序列化 序列是对象 静态成员变量是是属于类的
 * 
 * 序列化 相当于是 把对象进行持久化
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //writeObject();
        readObject();
    }

    /**
     * @throws FileNotFoundException
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void readObject() throws FileNotFoundException, IOException, ClassNotFoundException {
        // 读取序列化文件(反序列化)
        // 在进行反序列化(读取)的时候 需要依赖你的便以文件.class文件 来进行读取的
        FileInputStream fis = new FileInputStream("/Users/lanou/Desktop/Test/person.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 读文件
        Object object = ois.readObject();
        System.out.println(object);
        ois.close();
    }

    /**
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static void writeObject() throws FileNotFoundException, IOException {
        // 注意:如果要对对象进行实例化 必须要实现Serializable(序列化接口) 该接口是标记型接口
        // 注意 写对象都使用字节流去操作
        FileOutputStream fos = new FileOutputStream("/Users/lanou/Desktop/Test/person.txt");
        //创建对象输出流(序列化流)
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //使用写对象的方法
        oos.writeObject(new Person("dp", 15));
        oos.close();
    }