52.3 字节缓冲流的性能分析

try（）小括号里面是写要释放的资源 （一般是写输入流和输出流的对象） —InputStream is = new FileInputStream(SRC_FILE);
OutputStream os = new FileOutputStream(DEST_FILE + “video1.mp4”);

try{} 大括号里面是写捕获异常的代码

使用缓冲的字节流按照一个一个字节数组的形式复制文件耗时最少 速度最快 （最推荐）

总结：

这种方式：是将字节流 每次读取 1024 8 8kb 的读 —- 字节数组的长度为1024， 从代码看来表达的是每次从文件读取1024个字节。 每个英文占用一个字节 所以该字符数组new byte[1024] 可以存储 1024个英文字母
*// 将桶加大，加快读写的熟读

package com.itheima.d2_byte_buffer_time;
import java.io.*;
public class ByteBufferTimeDemo {
    // 定义一个静态的字符串类型的常量 地址  （随着类加载） 可以在本类可以直接调用
    // 源文件
    private  static   final String SRC_FILE = "C:\\Users\\aufs\\Desktop\\是心之所向 - 抖音.mp4";
    // 目的地：  不要把地址写死，这样只能复制同一份， 写目的地可以动态的复制多份
    // 目的地地址加\\ 后面可以用字符串拼接，直接拷贝到该路径下
    private static final String DEST_FILE = "C:\\Users\\aufs\\Pictures\\Saved Pictures\\";
    public static void main(String[] args) {
        copy01(); // 使用低级的字节流按照一个一个字节的形式复制文件
        copy02(); // 使用低级的字节流按照一个一个字节数组的形式复制文件  每个英文占一个字节
        // （字节数组的好处：每次可以倒一定的量-- 取决于数组元素的长度1024 每次可以倒1024个字节长度） 也可以每次读1024个字节
        copy03(); // 缓冲流一个一个字节复制
        copy04(); // 缓冲流一个一个字节数组的赋值
    }
    private static void copy04() {
        long startTime = System.currentTimeMillis();
        try (
                // 1. 创建高级缓冲的字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE); // 这就是定义常量的好处，将不可变的路径赋值给输入流
                InputStream bis = new BufferedInputStream(is);
                // 2. 创建低级的字节输出流与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video4.mp4"); // 要输出的位置 加复制后的新文件名（动态赋值)
                // b. 把字节输出流管道包装成高级的缓冲字节输出流管道
                OutputStream bos = new BufferedOutputStream(os);
        ) {
            // 3. 定义一个字节数组转移数据
            byte[] buffer = new byte[1024]; // 1024B(字节) = 1kB
            int len; // 记录每次读取的数据  因为最后一桶水可能装不满  主要是记录最后一桶水读取了多少
            while ((len = bis.read(buffer)) != -1) { // 当读取不到时 会返回 -1 如果不等于-1，则执行下面代码
                // 用缓冲字节输出流管道对象写bos    优点会很快（缓冲池都在内存中）
                bos.write(buffer, 0, len); // 有多少写多少(用缓冲对象写）
            }
            System.out.println("复制完成 ");
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 获取结束时间的毫秒值
        long endTimer = System.currentTimeMillis();
        // 将毫秒值 /1000.0  转换成秒的同时也可以保留小数位
        System.out.println("使用缓冲的字节流按照一个一个字节数组的形式复制文件耗时：" + (endTimer - startTime)/1000.0 + "s");
    }
    /**
     *   缓冲流一个一个字节的复制
     */
    private static void copy03() {
        // currentTimeMillis  是获取当前时间的毫秒值
        long startTime = System.currentTimeMillis();
        try ( // try 是捕获异常
              // 在try 的小括号里面写都是写  资源 （要自动释放的资源）
              // 1. 创建高级缓冲的字节输入流与源文件接通
              InputStream is = new FileInputStream(SRC_FILE); // 这就是定义常量的好处，将不可变的路径赋值给输入流
              InputStream bis = new BufferedInputStream(is);
              // 2. 创建低级的字节输出流与目标文件接通
              OutputStream os = new FileOutputStream(DEST_FILE + "video3.mp4"); // 要输出的位置 加复制后的新文件名（动态赋值)
              // b. 把字节输出流管道包装成高级的缓冲字节输出流管道
              OutputStream bos = new BufferedOutputStream(os);
        ){
            // try 的中括号里面是写捕获异常的代码
            int b; // 记录每次读取的字节数
            while ((b = bis.read()) != -1){
                bos.write(b); // 读取到文件后，用输出流写入对应的字节数给目标文件对象os
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 获取结束时间的毫秒值
        long endTimer = System.currentTimeMillis();
        // 将毫秒值 /1000.0  转换成秒的同时也可以保留小数位
        System.out.println("使用缓冲的字节流按照一个一个字节的形式复制文件耗时：" + (endTimer - startTime)/1000.0 + "s");
    }
    /**
     * 使用低级的字节流按照一个一个字节数组的形式复制文件
     */
    private static void copy02() {
        // currentTimeMillis  是获取当前时间的毫秒值
        long startTime = System.currentTimeMillis(); // 获取开始的时间
        try (   // try括号里面都是资源对象（输入流和输出流）
                // 用完之后会自动调用close方法
                // 这里面只能放置资源对象，用完全自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
                // 1. 创建一个字节输入流管道与原视频接通
                InputStream is = new FileInputStream(SRC_FILE);
                // 2.创建一个字节输出流管道与目标文件接通  输出： 将内存输出到硬盘（保存的感觉）
                OutputStream os = new FileOutputStream(DEST_FILE + "video2.mp4");
        ) {
            // 3. 定义一个字节数组转移数据
            byte[] buffer = new byte[1024]; // 1024B(字节) = 1kB
            int len; // 记录每次读取的数据  因为最后一桶水可能装不满  主要是记录最后一桶水读取了多少
            while ((len = is.read(buffer)) != -1) { // 当读取不到时 会返回 -1 如果不等于-1，则执行下面代码
                // 用缓冲字节输出流管道对象写bos    优点会很快（缓冲池都在内存中）
                os.write(buffer, 0, len); // 有多少写多少
            }
            System.out.println("复制完成 ");
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 获取结束时间的毫秒值
        long endTimer = System.currentTimeMillis();
        // 将毫秒值 /1000.0  转换成秒的同时也可以保留小数位
        System.out.println("使用低级的字节流按照一个一个字节数组的形式复制文件耗时：" + (endTimer - startTime)/1000.0 + "s");
    }
    /**
     * 使用低级的字节流按照一个一个字节的形式复制文件
     */
    private static void copy01() {
        // currentTimeMillis  是获取当前时间的毫秒值
        long startTime = System.currentTimeMillis(); // 获取开始的时间
        try ( // try 是捕获异常
              // 在try 的小括号里面写都是写  资源 （要自动释放的资源）
                // 1. 创建低级的字节输入流与源文件接通
              InputStream is = new FileInputStream(SRC_FILE); // 这就是定义常量的好处，将不可变的路径赋值给输入流
              // 2. 创建低级的字节输出流与目标文件接通
              OutputStream os = new FileOutputStream(DEST_FILE + "video1.mp4"); // 要输出的位置 加复制后的新文件名（动态赋值)
                ){
                // try 的中括号里面是写捕获异常的代码
            int b; // 记录每次读取的字节数
            while ((b = is.read()) != -1){
                os.write(b); // 读取到文件后，用输出流写入对应的字节数给目标文件对象os
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 获取结束时间的毫秒值
        long endTimer = System.currentTimeMillis();
        // 将毫秒值 /1000.0  转换成秒的同时也可以保留小数位
        System.out.println("使用低级的字节流按照一个一个字节的形式复制文件耗时：" + (endTimer - startTime)/1000.0 + "s");
    }
}