字节缓冲流性能分析

分别使用四种字节缓冲流进行文件复制测试其速度

这里准备了一个较大的视频文件130MB的视频文件进行测试

import com.wukong.io.BufferedInputStreamDemo02;

import java.io.*;

public class BufferedInputStreamDemo01 {

    public static final String SRC_FILE ="E:\\project\\教学\\C1 认证\\Web基础第四讲、.mp4";
    public static final String DEST_FILE ="D:\\test\\abc\\cc";

    public static void main(String[] args) throws IOException {
        //copy1();//低级流一个一个字节复制速度太慢，禁止使用
        copy2();//低级的字节流按照一个一个的数组形式复制较慢   2.383s
        copy3();//高级缓冲字节流按照一个一个字节复制速度较慢   4.211s
        copy4();//高级缓冲字节流流按照一个一个数组复制速度极快 建议使用  0.443s
    }
        //使用低级的字节流文件按照一个一个字节的形式复制文件。
        public static void copy1(){
            long startTime = System.currentTimeMillis();
            try(
                    InputStream is  = new FileInputStream(SRC_FILE);
                    OutputStream os = new FileOutputStream(DEST_FILE+"01.mp4")
            ){
                //定义一个整型变量存取字节
                int ch;
                while ((ch =is.read()) != -1){
                    os.write(ch);
                }

            }catch (Exception e){
                e.printStackTrace();
            }
            long endTimer = System.currentTimeMillis();
            System.out.println("使用低级的字节流方式按照一个一个字节的形式复制文件耗时"+(endTimer-startTime)/1000.0+"s");
        }

        //使用低级的字节流文件按照一个一个字节数组的形式复制文件。
        public static void copy2(){
            long startTime = System.currentTimeMillis();
            try(
                    InputStream is  = new FileInputStream(SRC_FILE);
                    OutputStream os = new FileOutputStream(DEST_FILE+"02.mp4")
            ){
                //定义一个字节数组存储字节
                byte[] buffer = new byte[1024];
                int len;
                while ((len =is.read(buffer)) != -1){
                    os.write(buffer,0,len);
                }

            }catch (Exception e){
                e.printStackTrace();
            }
            long endTimer = System.currentTimeMillis();
            System.out.println("使用低级的字节流方式按照一个一个字节数组的形式复制文件耗时"+(endTimer-startTime)/1000.0+"s");
        }

        //使用高级的字节流文件按照一个一个字节的形式复制文件。
        public static void copy3() throws IOException {
            long startTime = System.currentTimeMillis();
            try(
                    InputStream is  = new FileInputStream(SRC_FILE);
                    BufferedInputStream bis = new BufferedInputStream(is);
                    OutputStream os = new FileOutputStream(DEST_FILE+"03.mp4");
                    BufferedOutputStream bos = new BufferedOutputStream(os);
            ){
                //定义一个整型变量存取字节
                int ch;
                while ((ch =bis.read()) != -1){
                    bos.write(ch);
                }

            }catch (Exception e){
                e.printStackTrace();
            }
            long endTimer = System.currentTimeMillis();
            System.out.println("使用高级缓冲字节流方式按照一个一个字节的形式复制文件耗时"+(endTimer-startTime)/1000.0+"s");
        }


        //使用高级的字节流文件按照一个一个字节的形式复制文件。
        public static void copy4() throws IOException {
            long startTime = System.currentTimeMillis();
            try(
                    InputStream is  = new FileInputStream(SRC_FILE);
                    BufferedInputStream bis = new BufferedInputStream(is);
                    OutputStream os = new FileOutputStream(DEST_FILE+"04.mp4");
                     BufferedOutputStream bos = new BufferedOutputStream(os);
            ){
                //定义一个字节数组存储字节
                byte[] buffer = new byte[1024];
                int len;
                while ((len =bis.read(buffer)) != -1){
                    bos.write(buffer,0,len);
                }

            }catch (Exception e){
                e.printStackTrace();
            }
            long endTimer = System.currentTimeMillis();
            System.out.println("使用高级缓冲字节流方式按照一个一个字节数组的形式复制文件耗时"+(endTimer-startTime)/1000.0+"s");
        }

}

测试结果：

小结：

• 使用高级缓冲字节流方式按照一个一个字节数组的形式复制文件较快，建议日常使用。

文档顺序恢复

请将下述文档恢复顺序：

五.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。
六.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
七.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐托付不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
九.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
十.今当远离，临表涕零，不知所言。
三.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必能裨补阙漏，有所广益。
四.将军向宠，性行淑均，晓畅军事，试用于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
一.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
二.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
八.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

案例分析：

1. 创建一个缓冲字符输入流对象包装字符输入流接通源文件。
2. 定义一个List 集合用与读取每段文章
3. 定义语法循环按照行读取每段文章，，存入到List集合中去。
4. 对List 集合中的每个元素按照首字母字符排序
5. 创建缓冲字符输出流管道通向目标文件
6. 遍历List集合中的每个元素，通过缓冲字符输出管道写出到目标文件。
7. 释放资源

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.*;
/*
     分析：
     1.创建一个缓冲字符输入流对象包装字符输入流接通源文件。
     2.定义一个List 集合用与读取每段文章
     3.定义语法循环按照行读取每段文章，，存入到List集合中去。
     4.对List 集合中的每个元素按照首字母字符排序
     5.创建缓冲字符输出流管道通向目标文件
     6.遍历List集合中的每个元素，通过缓冲字符输出管道写出到目标文件。
     7.释放资源
 */
public class ExecDemo01 {
    public static void main(String[] args) {
        //
        try(//创建一个缓冲字符输入流对象包装字符输入流接通源文件。
            BufferedReader br = new BufferedReader(new FileReader("src\\com\\wukong\\iotwo\\csb1.txt"));
            //创建缓冲字符输出流管道通向目标文件
            BufferedWriter bw = new BufferedWriter(new FileWriter("src\\com\\wukong\\iotwo\\newcsb.txt"));
                ){
            //定义一个List 集合用与读取每段文章
            List<String> datas = new ArrayList<String>();
            String line;
            while ((line = br.readLine())!=null){
                datas.add(line);
            }
            List<Character> sizes = new ArrayList<>();
            Collections.addAll(sizes,'零','一','二','三','四','五','六','七','八','九','十');
            //对List 集合中的每个元素按照首字母字符排序
            Collections.sort(datas, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                //s1
                //s2
                // indexOf 获取元素在List的集合中的索引
                return sizes.indexOf(s1.charAt(0))-sizes.indexOf(s2.charAt(0));
            }
        });
            System.out.println(datas);

            for (String data:datas) {
                bw.write(data);
                bw.newLine();
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

测试结果：