目录
二、字节缓冲输出流(BufferedOutputStream)
①BufferedOutputStream(OutputStream out)
②BufferedOutputStream(OutputStream out, int size)
三、字节缓冲输入流(BufferedInputStream)
①BufferedInputStream(InputStream in)
②BufferedInputStream(InputStream in, int size)
BufferedWriter(Writer out, int sz)
BufferedReader(Reader in, int sz)
一、概述
1、简介
缓冲流,也叫高效流,是对4个基本的FileXXX的增强,所以也是4个流;
缓冲流内部有一个缓冲区,可以提高读写的效率。
缓冲流真正并不具备读写的功能,缓冲流真正的作用是给其他流提供加速。
2、按照数据类型分为
字节缓冲流:BufferedInputStream和BufferedOutputStream;
字符缓冲流:BufferedReader和BufferedWriter;
3、基本原理
在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统的IO次数,从而提高读写的效率;
二、字节缓冲输出流(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();
}
}
运行结果:
三、字节缓冲输入流(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();
}
}
运行结果:
五、字符缓冲输入流(BufferedReader)
1、继承自父类的共性成员方法
①abstract void close()关闭该流并释放与之关联的所有资源;
③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();
}
}
运行结果: