java、IO流之缓冲流详解

一篇快速理解JavaIO流

缓冲流

缓冲流是处理流的一种，对已有的节点流进行一个包装。
缓冲流的主要作用就是提高流的读取，写入效率。
 在这里讲一讲直接操作文件的缓冲流。

抽象基类	节点流(文件流)	缓冲流（节点流的一种）
InputStream	FileInputStream	BufferedInputStream
outputStream	FileOutputStream	BufferedOutputStream
Reader	FileReader	BufferedReader
Writer	FileWriter	BufferedWriter
前置知识：
java中IO流File类，
IO流中的节点流

BufferedInputStream & BufferedOutputStream

下面用一个例子演示一下节点流中的缓冲流：
eg：把D:/团圆照.jpg (已经存在)，这张d盘下的团圆照图片，复制(write)到F盘下，命名为：合家欢喜.jpg（还不存在，就算存在也可覆盖）：

    @Test
    public void BufferedStream(){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try {
            //提供file对象
            File file1 = new File("D:\\团圆照.jpg");
            File file2 = new File("F:\\合家欢喜.jpg");

            //造节点流
            fileInputStream = new FileInputStream(file1);
            fileOutputStream = new FileOutputStream(file2);

            //造缓冲流
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

            //复制的细节，读取，写入
            int len;
            byte[] data = new byte[1024];
            while((len = bufferedInputStream.read(data)) != -1){
                bufferedOutputStream.write(data,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //流的关闭
            //要求，先关闭外层的流，再关闭内层的流
            try {
                if(bufferedInputStream != null) bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(bufferedOutputStream != null) bufferedOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭，关于内层流的关闭，我们可以省略。
//            fileInputStream.close();
//            fileOutputStream.close();
        }
    }

能够提高读写速度的原因，缓冲流内部提供了一个缓冲区，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

BufferedReader & BufferedWriter

同样用一个例子演示一下字符流中的缓冲流：
eg：把D:/hello1.txt(已经存在)，这个d盘下的文件，复制(write)到F盘下，命名为：hello.txt（还不存在，就算存在也可覆盖）：

    @Test
    public void BufferReaderTest(){
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            //有了前面知识的积累，这里就写的简化一点。
            bufferedReader = new BufferedReader(new FileReader(new File("D:\\hello1.txt")));
            bufferedWriter = new BufferedWriter(new FileWriter(new File("F:\\hello.txt")));
            //复制
            int len = 0;
            //方式一：使用char[]
//            char[] data = new char[1024];
//            while ((len = bufferedReader.read(data)) != -1){
//                bufferedWriter.write(data,0,len);
//            }
            //方式二：使用String
            String data;
            while ((data = bufferedReader.readLine()) != null){
                bufferedWriter.write(data);//data中不包含换行符
                bufferedWriter.newLine();//加一个换行符
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedReader != null) bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(bufferedWriter != null) bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

这是我的一篇笔记，借鉴视频：康师傅讲java