IO流--缓冲流概述和使用

缓冲流是处理流的一种。
缓冲流，也叫高效流。能够高效读写缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化对象等等。
按照数据类型分类：
  处理字节-字节缓冲流：BufferedInputStream，BufferedOutputStream
  处理字符-字符缓冲流：BufferedReader，BufferedWriter
缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组(8192)，通过缓冲区读写，减少系统IO读取次数，从而提高读写的效率。
缓冲流不能直接作用在文件上，他只能作用在节点流上，使用缓冲流包装节点流来使用。
在编码过程中记得程序执行完后一定要关闭资源，只需要关闭外层的处理流，内部的节点流自动关闭。

缓冲字节流：(BufferedInputStream和BufferedOutputStream)的使用

/**
     * 对视频文件进行复制
     * BufferedInputStream和BufferedOutputStream
     */
    @Test
    public void test1() {
        //创建外层字节缓冲流
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            //创建文件
            File srcFile = new File("/Applications/file/video1.avi"); //源文件
            File destFile = new File("/Applications/file/video2.avi"); //目标文件

            //创建内层节点流
            FileInputStream fileInputStream = new FileInputStream(srcFile);
            FileOutputStream fileOutputStream = new FileOutputStream(destFile);

            //创建外层字节缓冲流
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

            long start = System.currentTimeMillis();

            //对文件进行复制，读取写入
            byte[] bytes = new byte[1024];
            int len;
            while ((len = bufferedInputStream.read(bytes)) != -1) {
                bufferedOutputStream.write(bytes, 0, len);
            }
            long end = System.currentTimeMillis();

            System.out.println("复制文件耗时：" + (end - start) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            //关闭外层缓冲流
            if(bufferedOutputStream != null) {
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bufferedInputStream != null) {
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

缓冲字符流：(BufferedReader和BufferedWriter)的使用

/**
     * 使用缓冲字符流对文本文件进行复制
     * BufferedReader和BufferedWriter
     */
    @Test
    public void test2() {
        //创建外层字符缓冲流
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;

        try {
            //创建文件
            File srcFile = new File("hello.txt");   //源文件
            File destFile = new File("hello2.txt"); //目标文件

            //创建字符节点流
            FileReader fileReader = new FileReader(srcFile);
            FileWriter fileWriter = new FileWriter(destFile);

            bufferedReader = new BufferedReader(fileReader);
            bufferedWriter = new BufferedWriter(fileWriter);

            //对文件进行复制，读取写入
            //方式一：使用char型数组
//            char[] chars = new char[1024];
//            int len;
//            while ((len = bufferedReader.read(chars)) != -1) {
//                bufferedWriter.write(chars, 0, len);
//            }
            //方式二：使用字符串，每次读取一行
            String str;
            while ((str = bufferedReader.readLine()) != null) {
                //方法1：不包含换行符
//                bufferedWriter.write(str + "\n");//str不包含换行符，需要自己添加

                //方法2：包含换行符
                bufferedWriter.write(str);
                bufferedWriter.newLine();   //换行符
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭外层字符缓冲流
            if(bufferedWriter != null) {
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }