文章目录

---

前言

        输入输出流可以视为，从A点把货物搬运至B点。那么带缓冲的意思可以视为用货车把A点的货物搬运至B点。顾名思义，带有缓存的输入输出流运行效率更高。本篇文章讲述输入输出流更深一步的使用。

---

一、带缓存的输入输出流是什么？

        缓存是I/O的一种性能优化。缓存流为I/O流增加了内存缓存区，相当于运输货物过程中的货箱。有了缓存区（比喻，货箱），使得在流上执行skip()、mark()与reset()方法都可以使用。总而言之，这篇文章讲述，在输入输出流外部进行包装，带有缓存功能，提高IO流效率。（需要导入java.io包）

二、使用方法

1.BufferedInputStream与BufferedOutputStream类

构造方法：

new BufferedInputStream(InputStream in);
//将字节输入流包装成一个带有32个字节的缓存字节输入流

new BufferedInputStream(InputStream in,int size);
//将字节输入流包装成一个带有指定个数字节的缓存字节输入流

new BufferedOutputStream(OutputStream out);
//将字节输出流包装成一个带有32个字节的缓存字节输出流

new BufferedOutputStream(OutputStream out,int size);
//将字节输出流包装成一个带有指定个数字节的缓存字节输出流

实操展示：

项目：通过缓存字节输出流输入数据至文件中，再由缓存字节输入流读取出来。计时运行时间，比较一下带缓存和不带缓存的区别。

import java.io.*;
public class Demo {
    public static void main(String[] args) {
        File file = new File("show.txt");
        
        BufferedOutputStream outputStream2 = null;
        FileOutputStream outputStream = null;
        
        BufferedInputStream inputStream2 = null;
        FileInputStream inputStream = null;
        
        long startime = System.currentTimeMillis();
        try{
           
            outputStream = new FileOutputStream(file);
            outputStream2 = new BufferedOutputStream(outputStream);
            String str = "安得广厦千万间";
            byte b[] = str.getBytes();
            outputStream2.write(b);
            outputStream2.flush();  
//包装后需要每次写入都刷新一下，保证写入内容完整，装不满字节数是不会写入的，刷新直接将其写入

            byte b2[] = new byte[1024];
            inputStream = new FileInputStream(file);
            inputStream2 = new BufferedInputStream(inputStream);
            int len = inputStream2.read(b2);
            System.out.println("文件内容："+new String(b2,0,len));
            while (inputStream.read(b2)!=-1);
            long endtime2 = System.currentTimeMillis();
            System.out.println("带缓存的字节输入流所耗时间为："+(endtime2-startime));
            while (inputStream.read(b)!=-1);
            long endtime = System.currentTimeMillis();
            System.out.println("字节输入流所耗时间为："+(endtime-startime));


        }catch(IOException e){
            e.printStackTrace();
        }finally{
            try {
                //先开启的流最后关闭，开关顺序为 123，321
                outputStream2.close();
                outputStream.close();
                inputStream2.close();   
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedOutputStream类缓冲输出字节流使用注意：

（1）在try代码块中实例化，括号引入FileOutputStream对象，进行包装，带入缓冲。

（2）在调用write()方法写入信息时，同时要调用flush()方法刷新，保证字符数据完整存入。

（3）最先开启的流，最后关闭。流的开关顺序为 123，321

BufferedInputStream类缓冲输入字节流使用注意：

（1）在try代码块中实例化，括号引入FileInputStream对象，进行包装，带入缓冲。

（2）最先开启的流，最后关闭。流的开关顺序为 123，321

 运行结果：

        如图所示，带有缓存的字节输入流读取信息的速度更快。无论是输入流还是输出流，带上缓存的目的都是为了提高运行效率。 

2.BufferedReader与BufferedWriter类

        BufferedReader类和BufferedWriter类分别继承了Reader类和Writer类，可以使用其基本方法的同时本施也增加了些方法。 

构造方法：

new BufferedWriter(FileWriter writer);
//将字符输入流包装成一个带有32个字节的缓存字符输入流

new BufferedReader(FileReader reader);
//将字符输出流包装成一个带有32个字节的缓存字符输出流

BufferedWriter类的常用方法

方法	功能描述
write(String s,int off,int len)	写入字符串s的某一部分（从off到len）
flush()	刷新该流的缓存，缓存字符保存进文件中
newLine()	写入一个行分隔符，换行

BufferedReader类的常用方法

方法	功能描述
read()	读取单个字符
readLine()	读取一个文本行，并将其返回为字符串。若无数据返回null值。不断读取下一行，直到遇到文件末尾。

 实操展示：

import java.io.*;
public class Demo {
    public static void main(String[] args) {
        File file = new File("show.txt");
        
        BufferedWriter writer = null;
        FileWriter writer2 = null;

        BufferedReader reader = null;
        FileReader reader2 = null;

        try{
           
            writer2 = new FileWriter(file);
            writer = new BufferedWriter(writer2);
            String str1 = "长亭外，古道边，芳草碧连天。";
            String str2 = "晚风拂柳笛声残，夕阳山外山。";
            writer.write(str1);
            writer.newLine();   //换行输入内容
            writer.write(str2);
            writer.flush(); //刷新

            reader2 = new FileReader(file);
            reader = new BufferedReader(reader2);
      
            String tmp = null;
            int i = 1;  //计数器
            while ((tmp=reader.readLine())!= null) {
                //使用readLine()方法读取下一行信息，不需要引入参数保存数据。
                System.out.println("第"+i+"行的内容为："+tmp);
                i++;
            }

        }catch(IOException e){
            e.printStackTrace();
        }finally{
            try {
                //先开启的流最后关闭，开关顺序为 123，321

                writer.close();
                writer2.close();

                reader.close();
                reader2.close();
              
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedWriter类缓冲输入字节流使用注意：

（1）在try代码块中实例化，括号引入FileInWriter对象，进行包装，带入缓冲。

（2）在调用write()方法写入信息时，同时要调用flush()方法刷新，保证字符数据完整存入。

（3）最先开启的流，最后关闭。流的开关顺序为 123，321

BufferedReader类缓冲输出字节流使用注意：

（1）在try代码块中实例化，括号引入FileOutputStream对象，进行包装，带入缓冲。

（2）最先开启的流，最后关闭。流的开关顺序为 123，321

运行结果：

文件输入内容 

 

 文件输出内容

        如图所示，字符输入输出流包装后，带入缓存。不仅能提升字符数据传输的效率，而且还能使用额外方便的方法，例如，readLine()、newLine等。 

---

总结

        以上就是带缓存的输入输出流，本文只是简单介绍了带缓存的输入输出流的使用，而输入输出流带上缓存既能提高运行速度，又有新的便利的方法可供使用。