Java基础 -＞ IO流,缓冲流(BufferInputStream,BudderOutputStream),处理流--附加转换流

BufferInputStream BudderOutputStream花费的时间为3

    /**
     * 使用处理流时:花费的时间为3
     * 处理流:包在字节流外边的流,用来处理字节流,提高读写速度
     *       bufferedInputStream = new BufferedInputStream(fileInputStream);
     *       bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
     *      内部有缓存区,缓存一定范围数量的数据,之后一起输入输出
     *       private static int DEFAULT_BUFFER_SIZE = 8192;缓存范围就是8192
     *          .flush():刷新缓冲,调用这个方法就直接输入输出,不需要存满
     *
     */
    @Test
    public void test(){
        long start = System.currentTimeMillis();
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try {
            //1.找到/创建文件,指定输出的文件
            //字节流处理图片等,字符流处理txt
            File file = new File("Test922示例图.png");
            File file1 = new File("Test922复制图.png");
            //2.节点流,定义输入输出
            FileInputStream fileInputStream = new FileInputStream(file);
            FileOutputStream fileOutputStream = new FileOutputStream(file1);
            //3.处理流,定义输入输出
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
            //4.输入输出,传递数据
            byte[] bytes = new byte[1024];
            int len;
            while ((len = bufferedInputStream.read(bytes)) != -1){
                bufferedOutputStream.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流;  有处理流,就只需要关闭处理流,字节流会自己关闭的
            //因为你可以写成这样,你也关不了字节流的,只能关闭处理流
            // bufferedInputStream = new BufferedInputStream(new FileInputStream(file));
            if (bufferedInputStream!=null){
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedOutputStream!=null){
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();
        //程序运行消耗时间
        System.out.println("运行时间:" + (end-start));//运行时间:3
    }

不使用处理流时:花费的时间为33

/**
     * 不使用处理流时:花费的时间为33
     */
    @Test
    public void test1(){
        long start = System.currentTimeMillis();
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            File file = new File("Test922示例图.png");
            File file1 = new File("Test922复制图.png");
            fileInputStream = new FileInputStream(file);
            fileOutputStream = new FileOutputStream(file1);
            //byte[1024],数值大点,运行速度快
            byte[] bytes = new byte[1024];
            int len;
            while ((len = fileInputStream.read(bytes)) != -1){
                fileOutputStream.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream!=null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("运行时间:" + (end-start));//运行时间:33
    }

附加:转换流–转换编码格式(处理流)

/**
     * 处理字符流:转换编码格式
     * InputStreamReader:将字节流转化为字符流(char)输入
     * OutputStreamWriter:将字符转换为字节流(byte)输出
     */
    @Test
    public void test2(){
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            //1.找到/创建文件,指定输出的文件
            //字节流处理图片等,字符流处理txt
            File file = new File("Test921.txt");
            File file1 = new File("Test922复制文件.txt");
            //2.节点流,定义输入输出
            //Test921.txt是GBK编码的,就需要用gbk来解码,idea/eclipse用的是utf-8,解码会有乱码
            //将数据冲文件输入到内存,要使用文件相对应的格式去解码
            //FileReader是没有转码的构造器的,所以使用了它的父类的构造器
            //相应的也有OutputStreamReader的构造器
            InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file),"gbk");
            FileWriter fileWriter = new FileWriter(file1);

            //这是冲内存输出到文件,可以选择输出的格式是不同的编码.例如输出为gbk格式的
//            FileReader fileReader = new FileReader(file);
//            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file1),"gbk");

            //3.处理流,定义输入输出
            bufferedReader = new BufferedReader(inputStreamReader);
            bufferedWriter = new BufferedWriter(fileWriter);

            //4.输入输出,传递数据
            int len;
            while ((len = bufferedReader.read()) != -1){
                bufferedWriter.write(len);
            }
            //另一个方法
//            String tem;
//            int len;
//            //.readLine()只输出一行且不会自动换行
//            while ((tem = bufferedReader.readLine()) != null){
//                //手动换行
//                bufferedWriter.write(tem + "\n");
//            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流;  有处理流,就只需要关闭处理流,字节流会自己关闭的
            if (bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedWriter!=null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }