Java缓冲流详解

r囧r小猫 2023-10-18 22:08 122阅读 0赞

**目录**

一、概述

1、简介

2、按照数据类型分为

3、基本原理

二、字节缓冲输出流（BufferedOutputStream）

1、继承自父类的共性成员方法

2、构造方法

①BufferedOutputStream(OutputStream out)

②BufferedOutputStream(OutputStream out, int size)

参数说明：

3、使用步骤（重点）

4、代码演示

代码：

运行结果：

三、字节缓冲输入流（BufferedInputStream）

1、继承自父类的共性成员方法

2、构造方法

①BufferedInputStream(InputStream in)

②BufferedInputStream(InputStream in, int size)

参数说明：

3、使用步骤（重点）

4、代码演示

四、字符缓冲输出流（BufferedWriter）

1、继承自父类的共性成员方法

2、特有的成员方法

void newline()

不同系统的不同分隔符：

3、构造方法

BufferedWriter(Writer out)

BufferedWriter(Writer out, int sz)

参数说明：

4、使用步骤（重点）

5、代码演示

代码：

运行结果：

五、字符缓冲输入流（BufferedReader）

1、继承自父类的共性成员方法

2、特有的成员方法

String readLine()

不同系统的不同分隔符：

3、构造方法

BufferedReader(Reader in)

BufferedReader(Reader in, int sz)

参数说明：

4、使用步骤（重点）

5、代码演示

代码：

运行结果：

--------------------

# 一、概述 #

## 1、简介 ##

缓冲流，也叫高效流，是对4个基本的FileXXX的增强，所以也是4个流；

缓冲流内部有一个缓冲区，可以提高读写的效率。

**缓冲流真正并不具备读写的功能，缓冲流真正的作用是给其他流提供加速。**

## 2、按照数据类型分为 ##

**字节缓冲流：**BufferedInputStream和BufferedOutputStream；

**字符缓冲流：**BufferedReader和BufferedWriter；

## 3、基本原理 ##

在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统的IO次数，从而提高读写的效率；

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70][]

# 二、字节缓冲输出流（BufferedOutputStream） #

## 1、继承自父类的共性成员方法 ##

①void close()关闭此输出流并释放与此流有关的所有系统资源；

②void flush() 刷新此输出流并强制写出所有缓冲的输出字节；

③void write(byte\[\] b)将 b.length 个字节从指定的 byte 数组写入此输出流；

④void write(byte\[\] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流；

⑤abstract void write(int b)将指定的字节写入此输出流；

## 2、构造方法 ##

### ①BufferedOutputStream(OutputStream out) ###

创建一个新的缓冲输出流，以将数据写入指定的底层输出流；

### ②BufferedOutputStream(OutputStream out, int size) ###

创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流；

### 参数说明： ###

**OutputStream out：**

字节输出流，我们可以传递FileOutputStream，缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率；

**int size：**

指定缓冲流内部缓冲区的大小，不指定则为默认大小；

## 3、使用步骤（重点） ##

①创建FileOutputStream对象，构造方法中绑定输出的目的地；

②创建BufferedOutputStream对象，构造方法中绑定FileOutputStream对象，提高FileOutputStream对象的效率；

③使用BufferedOutputStream的write方法，将数据写入到内部缓冲区中；

④使用BufferedOutputStream的flush方法，将内部缓冲区中的数据刷新到文件中；

⑤释放资源，会先调用flush刷新数据，其实第4步可以省略；

## 4、代码演示 ##

### 代码： ###

package study.io;
    
    import java.io.BufferedOutputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class BufferedOutputStreamTest {
        public static void main(String[] args) throws IOException {
            //①创建FileOutputStream对象，构造方法中绑定输出的目的地；
            FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test.txt");
            //②创建BufferedOutputStream对象，构造方法中绑定FileOutputStream对象，提高FileOutputStream对象的效率；
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
            //③使用BufferedOutputStream的write方法，将数据写入到内部缓冲区中；
            bufferedOutputStream.write(97);
            //④使用BufferedOutputStream的flush方法，将内部缓冲区中的数据刷新到文件中；
            bufferedOutputStream.flush();
            //释放资源，会先调用flush刷新数据，其实第4步可以省略；
            bufferedOutputStream.close();
            fileOutputStream.close();
        }
    }

### 运行结果： ###

![2019072113115766.png][]

# 三、字节缓冲输入流（BufferedInputStream） #

## 1、继承自父类的共性成员方法 ##

①void close()关闭此输入流并释放与该流关联的所有系统资源；

②abstract int read()从输入流中读取数据的下一个字节；

③int read(byte\[\] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中；

## 2、构造方法 ##

### ①BufferedInputStream(InputStream in) ###

创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用；

### ②BufferedInputStream(InputStream in, int size) ###

创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用；

### 参数说明： ###

**InputStream in：**

字节输出流，我们可以传递FileInputStream，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的写入效率；

**int size：**

指定缓冲流内部缓冲区的大小，不指定则为默认大小；

## 3、使用步骤（重点） ##

①创建FileInputStream对象，构造方法中绑定要读取的数据源；

②创建BufferedInputStream对象，构造方法中绑定FileInputStream对象，提高FileOutputStream对象的效率；

③使用BufferedInputStream的read方法，读取文件；

④释放资源；

## 4、代码演示 ##

package study.io;
    
    import java.io.BufferedInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class BufferedInputStreamTest {
        public static void main(String[] args) throws IOException {
            //①创建FileInputStream对象，构造方法中绑定要读取的数据源；
            FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test.txt");
            //②创建BufferedInputStream对象，构造方法中绑定FileInputStream对象，提高FileOutputStream对象的效率；
            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
            //③使用BufferedInputStream的read方法，读取文件；
            //读取一个字节
            System.out.println(bufferedInputStream.read());//97
            //读取多个字节
            byte[] bytes = new byte[1024];
            int len = bufferedInputStream.read(bytes);
            for (int i = 0; i < len; i++) {
                System.out.println(bytes[i]);
                //98
                //99
                //100
                //101
                //102
                //103
            }
            //④释放资源；
            bufferedInputStream.close();
            fileInputStream.close();
        }
    }

# 四、字符缓冲输出流（BufferedWriter） #

## 1、继承自父类的共性成员方法 ##

①abstract void close()关闭此流，但要先刷新它；

②abstract void flush()刷新该流的缓冲；

③void write(char\[\] cbuf)写入字符数组；

④abstract void write(char\[\] cbuf, int off, int len)写入字符数组的某一部分；

⑤void write(int c)写入单个字符；

⑥void write(String str)写入字符串；

⑦void write(String str, int off, int len)写入字符串的某一部分；

## 2、特有的成员方法 ##

### void newline() ###

写入一个行分隔符；

### 不同系统的不同分隔符： ###

Windows：\\r\\n

Linux：/n

Mac：/r

## 3、构造方法 ##

### BufferedWriter(Writer out) ###

创建一个使用默认大小输出缓冲区的缓冲字符输出流；

### BufferedWriter(Writer out, int sz) ###

创建一个使用给定大小输出缓冲区的新缓冲字符输出流；

### 参数说明： ###

**Writer out：**

字节输出流，我们可以传递FileWriter，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率；

**int sz：**

指定缓冲流内部缓冲区的大小，不指定则为默认大小；

## 4、使用步骤（重点） ##

①创建FileWriter对象，构造方法中绑定输出的目的地；

②创建BufferedWriter对象，构造方法中绑定FileWriter对象，提高FileWriter对象的效率；

③使用BufferedWriter的write方法，将数据写入到内部缓冲区中；

④使用BufferedWriter的flush方法，将内部缓冲区中的数据刷新到文件中；

⑤释放资源，会先调用flush刷新数据，其实第4步可以省略；

## 5、代码演示 ##

### 代码： ###

package study.io;
    
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class BufferedWriterTest {
        public static void main(String[] args) throws IOException {
            //①创建FileWriter对象，构造方法中绑定输出的目的地；
            FileWriter fileWriter = new FileWriter("C:\\Users\\Administrator\\Desktop\\test.txt");
            //②创建BufferedWriter对象，构造方法中绑定FileWriter对象，提高FileWriter对象的效率；
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            //③使用BufferedWriter的write方法，将数据写入到内部缓冲区中；
            bufferedWriter.write("你好，世界！");
            //换行
            bufferedWriter.newLine();
            bufferedWriter.write("你好，世界！");
            //换行
            bufferedWriter.newLine();
            bufferedWriter.write("你好，世界！");
            //④使用BufferedWriter的flush方法，将内部缓冲区中的数据刷新到文件中；
            bufferedWriter.flush();
            //⑤释放资源，会先调用flush刷新数据，其实第4步可以省略；
            fileWriter.close();
            bufferedWriter.close();
        }
    }

### 运行结果： ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 1][]

# 五、字符缓冲输入流（BufferedReader） #

## 1、继承自父类的共性成员方法 ##

①abstract void close()关闭该流并释放与之关联的所有资源；

②int read()读取单个字符；

③int read(char\[\] cbuf)将字符读入数组；

## 2、特有的成员方法 ##

### String readLine() ###

读取一个文本行（通过分隔符区分行）；

**返回值：**包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null；

### 不同系统的不同分隔符： ###

Windows：\\r\\n

Linux：/n

Mac：/r

## 3、构造方法 ##

### BufferedReader(Reader in) ###

创建一个使用默认大小输入缓冲区的缓冲字符输入流；

### BufferedReader(Reader in, int sz) ###

创建一个使用指定大小输入缓冲区的缓冲字符输入流；

### 参数说明： ###

**Reader in：**

字节输出流，我们可以传递FileReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的写入效率；

**int sz：**

指定缓冲流内部缓冲区的大小，不指定则为默认大小；

## 4、使用步骤（重点） ##

①创建FileReader对象，构造方法中绑定读取的数据源；

②创建BufferedReader对象，构造方法中绑定FileReader对象，提高FileReader对象的效率；

③使用BufferedReader的read方法，读取文件；

④释放资源；

## 5、代码演示 ##

### 代码： ###

package study.io;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    
    public class BufferedReaderTest {
        public static void main(String[] args) throws IOException {
            //①创建FileReader对象，构造方法中绑定读取的数据源；
            FileReader fileReader = new FileReader("C:\\Users\\Administrator\\Desktop\\test.txt");
            //②创建BufferedReader对象，构造方法中绑定FileReader对象，提高FileReader对象的效率；
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            //③使用BufferedReader的read方法，读取文件；
            //一次读取一个字符
            System.out.println(bufferedReader.read());//20320
            //一次读取一行字符
            System.out.println(bufferedReader.readLine());//好，世界！
            //一次读取多个字符
            char[] chars = new char[1024];
            int len = bufferedReader.read(chars);
            for (int i = 0; i < len; i++) {
                System.out.print(chars[i]);
                //你好，世界！
                //你好，世界！
            }
            //④释放资源；
            bufferedReader.close();
            fileReader.close();
        }
    }

### 运行结果： ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 2][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190721123822966.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[2019072113115766.png]: https://img-blog.csdnimg.cn/2019072113115766.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190721135047910.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2019072114101133.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70