IO流概述
IO流的概述和分类
输入流：把硬盘上的数据读取到内存中
- 字符输入流：读取字符
- 字节输入流：读取字节
输出流：把内存中的数据写入到硬盘中
- 字符输出流：写入字符
- 字节输出流：写入字节
字符流和字节流的区别
- 字节流读取的和写入都是字节；字符流读取的和写入的都是字符
- 使用字节流可以读写任意的文件，所有的数据（文本，音乐，视频，图片...），都是以字节的方式存储的
- 使用字节流读取的文件中若包含中文，因一次只读写一个字节（1/2 GBK，1/3 UTF-8 个中文），使用起来不方便，可能会出现乱码
- 使用字符流读取含有中文文本文件，一次读取一个字符（中文，英文，数字，符号...），使用起来很方便
什么时候使用字符流：读写文本文件（使用记事本打开能看懂）
什么时候使用字节流：读写非文本文件（图片，视频，音频...）
关闭和刷新的区别
- flush：把内存缓冲区中的数据刷新到文件中，刷新完之后，流对象可以继续使用
- close：释放资源（释放流相关的所有的系统资源和流对象），在释放资源之前，会把内存缓冲区中的数据刷新到文件中刷新完之后，流对象就已经关闭了，就不能在使用了
import java.io.FileWriter;
import java.io.IOException;
public class Demo02Writer {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("day21\\e.txt");
fw.write(66); // B
fw.flush(); // 把内存缓冲区中的数据刷新到文件中，刷新完之后，流对象可以继续使用
fw.write(67); // C
fw.close(); // 在释放资源之前，把内存缓冲区中的数据刷新到文件中，刷新完之后，流对象就已经关闭了,就不能在使用了
fw.write(68); // IOException: Stream closed
}
}IO流的异常处理（JDK7后）
自动释放资源，不用再手动释放资源
格式：
try(
// 定义流对象
AAA aaa = new AAA();
BBB bbb = new BBB();
){
可能产生异常的代码
aaa.read();
bbb.write();
}catch(定义一个异常相关的变量，接收异常对象){
异常的处理逻辑
}注意：
- 在 try 的后边增加一个()，在()中定义流对象那么这些流对象的作用域，就只在 try 中有效，执行完 try 中的代码，会自动释放流对象省略 finally
- 注意 try 后边的小括号中，不是任意对象都可以放，只有实现了 Closeable 接口的对象才能放
import java.io.*;
import java.util.Date;
public class Demo02JDK7After {
public static void main(String[] args) {
try(
//定义流对象
FileWriter fw = new FileWriter(new File("day21\\1.txt"), true);
){
for (int i = 1; i <= 10; i++) {
fw.write("你猜猜,我能写入到文件中吗?\r\n");
} catch(IOException e) {
e.printStackTrace();
}
try(
FileInputStream fis = new FileInputStream("c:\\2.jpg");
FileOutputStream fos = new FileOutputStream("d:\\2.jpg");
){
byte[] bytes = new byte[1024];
int len = 0;
while ((len = fis.read(bytes)) != -1){
fos.write(bytes, 0, len);
}
}catch (IOException e) {
e.printStackTrace();
}
}
}字节流
InputStream：字节输入流超类
java.io.InputStream：字节输入流（此抽象类是表示字节输入流的所有类的超类）
InputStream 里边定义了所有字节输入流中共性的成员方法，所有的字节输入流都可以使用这些方法共性的成员方法：
int read() // 从输入流中读取数据的下一个字节。
int read(byte[] b) // 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
/* 1.read方法的参数byte[]字节数组的作用：
起到缓冲作用，把读取到的字节依次存储到数组中
把数组一次性的由操作系统返回JVM，由JVM返回给java程序，效率高
数组的长度一般都定义为1024或者1024的整数倍
2.read方法的返回值int是什么?
每次读取的有效字节个数。int=-1 表示读取结束。
*/
void close() // 关闭此输入流并释放与该流关联的所有系统资源。OutputStream：字节输出流超类
java.io.OutputStream：字节输出流（此抽象类是表示输出字节流的所有类的超类）
OutputStream 里边定义了所有字节输出流中共性的成员方法，所有的字节输出流都可以使用共性的成员方法：
public void close() // 关闭此输出流并释放与此流相关联的任何系统资源。
public void flush() // 刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(int b) // 将指定的字节输出流。
public void write(byte[] b) // 将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off, int len) // 从指定的字节数组写入 len个字节，从偏移量 off开始输出到此输出流。FileInputStream：文件字节输入流
java.io.FileInputStream extends InputStream
作用：把文件中的数据，以字节的方式读取到内存中
构造方法：
public FileInputStream(String name)
public FileInputStream(File file)
/* 参数：传递要读取的数据源
String name：要读取的数据源是一个文件的路径
File file：要读取的数据源是一个文件
*/构造方法的作用：
1.会创建FileInputStream对象
2.会把创建好的FileInputStream对象，指向要读取文件的第一个字节
注意：使用构造方法创建对象，如果要读取的文件不存在，不会创建文件，会抛出文件找不到异常
使用字节输入流读取文件到内存中底层原理：
java程序 ==> JVM ==> 操作系统 ==> 调用系统中读取文件的方法 ==> 读取文件
使用示例
字节输入流的使用步骤:
1.创建FileInputStream对象，构造方法中绑定要读取的数据源
2.使用FileInputStream对象中的方法read，以字节的方式读取文件
3.释放资源
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
public class Demo01InputStream {
public static void main(String[] args) throws IOException {
/*
基本使用
*/
//1.创建FileInputStream对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("day21\\a.txt");
//2.使用FileInputStream对象中的方法read,以字节的方式读取文件
//int read() 从文件中一次读取一个字节并返回
/*
读取文件是一个重复的过程，所以可以使用循环优化
不知道文件中有多少字节，不知道循环多少次，使用while循环
循环结束的条件，read方法读取到-1的时候结束
循环中的布尔表达式：((len=fis.read()) != -1)
1.fis.read()：读取文件中的一个字节
2.len = fis.read()：把读取到的字节赋值给变量len
3.(len = fis.read()) != -1：判断变量len的值是否为-1
len不是-1就执行循环体，打印len(读取到的字节)
len是-1结束循环
*/
int len = 0;
while ((len=fis.read()) != -1){
System.out.print((char)len);
}
//3.释放资源
fis.close();
/*
使用字节输入流一次读取多个字节
*/
FileInputStream fis = new FileInputStream("day21\\b.txt");
byte[] bytes = new byte[1024];
int len = 0;
while ((len = fis.read(bytes)) != -1){
//System.out.println(Arrays.toString(bytes));
//System.out.println(len);//5 读取的有效字节个数
System.out.println(new String(bytes, 0, len));
}
fis.close();
}
}FileOutputStream：文件字节输出流
java.io.FileOutputStream extends OutputStream
作用：把内存中的字节写入到硬盘的文件中保存
构造方法:
public FileOutputStream(File file)
public FileOutputStream(String name)
/* 参数：输出的目的地
String name：输出的目的地就是一个文件路径
File file：输出的目的地就是一个文件
*/
// 字节输出流的续写和换行
public FileOutputStream(File file, boolean append)
public FileOutputStream(String name, boolean append)
/* 参数：File file|String name：写入数据的目的地
boolean append：续写的开关
true：可以续写，使用构造方法创建对象，文件名相同，不会创建新的文件覆盖之前同名的文件，会继续往文件的末尾写数据
false：不可以续写，使用构造方法创建对象，文件名相同，会创建一个新的空白文件覆盖之前同名的文件，在新的文件中写数据
换行：使用换行符号
Windows系统里，每行结尾是 回车+换行 ，即 \r\n
linux,Unix系统里，每行结尾只有 换行 ，即 \n
Mac系统里，每行结尾是 回车 ，即 \r 。从 Mac OS X开始与Linux统一。
*/ 构造方法的作用：
1.会创建FileOutputStream对象
2.会根据构造方法中传递的文件路径|文件，创建一个新的空白文件
3.会把FileOutputStream对象，指向创建好的文件，就可以往文件中写数据了
使用字节输出流往文件中写输出的底层过程：
java程序 ==> JVM ==> 操作系统(OS) ==> 调用系统中写数据的方法 ==> 把数据写入到文件中
使用示例
字节输出流的基本使用：
1.创建FileOutputStream对象，构造方法绑定要输出的目的地
2.使用FileOutputStream对象中的方法write，把数据写入到文件中
3.释放资源（关闭此文件输出流并释放与此流有关的所有系统资源）
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class Demo01OutputStream {
public static void main(String[] args) throws IOException {
/*
基本使用
*/
//1.创建FileOutputStream对象,构造方法绑定要输出的目的地
FileOutputStream fos = new FileOutputStream("day20\\1.txt");
//2.使用FileOutputStream对象中的方法write,把数据写入到文件中
fos.write(97);
//3.释放资源(关闭此文件输出流并释放与此流有关的所有系统资源)
fos.close();
/*
字节输出流中写多个字节的方法
*/
FileOutputStream fos = new FileOutputStream(new File("day20\\2.txt"));
// public void write(byte[] b) 一次把字节数组中所有的字节写入到文件中
byte[] bytes = {65, 66, 67, 68, 69, 70};
fos.write(bytes); //ABCDEF
/*
public void write(byte[] b, int off, int len) 一次把字节数组的一部分写入到文件中
int off:数组的开始索引,从哪个索引开始写
int len:写的字节个数
*/
fos.write(bytes, 2, 3); //CDE
// 把字符串转换为字节数组，写入到文件中
byte[] bytes2 = "中国".getBytes();
//IDEA默认使用UTF-8编码,1个中文占用3个字节 [-28, -72, -83, -27, -101, -67]
System.out.println(Arrays.toString(bytes2));
fos.write(bytes2);//中国
fos.close();
/*
字节输出流的续写和换行
*/
FileOutputStream fos = new FileOutputStream("day20\\3.txt", true);
for (int i = 1; i <=10 ; i++) {
fos.write(("你好" + i + "\r\n").getBytes());
}
fos.close();
}
}字符流
编码表
编码：把能看懂的文字，转换为看不懂的文字（字符 ==> 字节）
解码：把看不懂的文字，转换为能看懂的文字（字节 ==> 字符）
编码表：就是生活中的文字和计算机中文字的对应关系表
- a ==> 97 ==> 01100001 ==> 存储到计算机中
- 中 ==> 20013 ==> 0010000000001011 ==> 存储到计算机中
常用的编码表：
- ASCII字符集 ：英文，数字，标点符号和计算机中文字的对应关系
0 ==> 48 A ==> 65 a ==> 97
ISO-8859-1字符集：拉丁码表
拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
- ISO-8859-1 使用单字节编码，兼容ASCII编码。不支持中文
GBxxx字符集：国标
GB 就是国标的意思，是为了显示中文而设计的一套字符集。兼容ASCII表
- GB2312：简体中文码表。 7000多个简体汉字
- GBK：目前操作系统默认中文码表（简体，繁体），存储一个中文使用2个字节，21003个汉字
- GB18030：最新的中文码表。包含的文字最全(简体，繁体，少数民族，日韩文字)
Unicode字符集 ：万国码
UTF-8：最常用的万国表，兼容所有国家的文字
编码规则：
- 128个US-ASCII字符，只需一个字节编码。
- 拉丁文等字符，需要二个字节编码。
- 大部分常用字（含中文），使用三个字节编码。
- 其他极少使用的Unicode辅助字符，使用四字节编码。
Reader：字符输入流超类
java.io.Reader：字符输入流（用于读取字符流的抽象类）
是所有字符输入流最顶层的父类，里边定义了所有字符输入流共性的成员方法，所有的字符输入流都可以使用共性的成员方法：
int read() // 读取单个字符。
int read(char[] cbuf) // 将字符读入数组。
void close() // 关闭该流并释放与之关联的所有资源。Writer：字符输出流超类
java.io.Writer：字符输出流（ 写入字符流的抽象类）
是所有字符输出流最顶层的父类，里边定义了所有字符输出流中共性的成员方法，所有字符输出流都可以使用共性的成员方法：
abstract void close() // 关闭此输出流并释放与此流相关联的任何系统资源
abstract void flush() // 刷新此输出流并强制任何缓冲的输出字符被写出
void write(int c) // 写出一个字符
void write(char[] cbuf) // 将 b.length字符从指定的字符数组写出此输出流
void write(char[] b, int off, int len) // 从指定的字符数组写出len字符，从偏移量off开始输出到此输出流
void write(String str) // 写出一个字符串
void write(String str, int off, int len) // 写入字符串的某一部分InputStreamReader：字符转换输入流
java.io.InputStreamReader extends Reader
作用：InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。
解码：字节==>字符
构造方法：
public InputStreamReader(InputStream in) // 创建一个使用默认字符集的 InputStreamReader
public InputStreamReader(InputStream in， String charsetName) // 创建使用指定字符集的 InputStreamReader
/* 参数：
InputStream in：传递字节输入流，可以传递InputStream的任意的子类对象(读取文件中的字节)
String charsetName：传递编码表名称，不区分大小写的可以传递GBK（gbk），UTF-8（utf-8）...，
不写默认使用IDEA设置的编码（UTF-8）
*/继续自父类的共性成员方法：
int read() // 读取单个字符。
int read(char[] cbuf) // 将字符读入数组。
void close() // 关闭该流并释放与之关联的所有资源。OutputStreamWriter：字符转换输出流
java.io.OutputStreamWriter extends Writer
作用：OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。
编码：字符 ==> 字节
构造方法：
public OutputStreamWriter(OutputStream out) // 创建使用默认字符编码的 OutputStreamWriter。
public OutputStreamWriter(OutputStream out， String charsetName) // 创建使用指定字符集的 OutputStreamWriter。
/* 参数：
OutputStream out：传递字节输出流，可以传递OutputStream的任意子类对象(把字符转换之后的字节写入到文件中)
String charsetName：传递编码表名称，不区分大小写的可以传递GBK(gbk)，UTF-8（utf-8）...，
不写默认使用IDEA设置的编码(UTF-8)
*/继承自父类共性的成员方法：
public abstract void close() // 关闭此输出流并释放与此流相关联的任何系统资源。
public abstract void flush() // 刷新此输出流并强制任何缓冲的输出字符被写出。
public void write(int c) // 写出一个字符。
public void write(char[] cbuf) // 将 b.length字符从指定的字符数组写出此输出流。
public abstract void write(char[] b, int off, int len) // 从指定的字符数组写出len字符，从偏移量off开始输出到此输出流
public void write(String str) // 写出一个字符串
public void write(String str, int off, int len) // 写入字符串的某一部分。FileReader：文件字符输入流便捷类
java.io.FileReader extends InputStreamReader(转换流) extends Reader
作用：把文件中的数据以字符的方式读取到内存中
构造方法：
public FileReader(String fileName)
public FileReader(File file)
/* 参数：传递要读取的数据源
String fileName：数据源就是一个文件路径
File file：数据源就是一个文件
*/使用示例
使用字符输入流读取文件的步骤
1.创建FileReader对象,构造方法中绑定要读取的数据源
2.使用FileReader对象中的方法read,以字符的方式读取文件
3.释放资源
Stirng类的构造方法：
public String(char[] value) // 把字符数组转换为字符串
public String(char[] value, int offset, int count) // 把字符数组的一部分转换为字符串import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Demo02Reader {
public static void main(String[] args) throws IOException {
/*
基本使用
*/
//1.创建FileReader对象,构造方法中绑定要读取的数据源
FileReader fr = new FileReader("day21\\c.txt");
//2.使用FileReader对象中的方法read,以字符的方式读取文件
//int read() 一次读取一个字符并返回
/*int len = 0;
while ((len = fr.read()) != -1){
System.out.print((char)len);
}*/
//int read(char[] cbuf) 使用数组缓冲一次读取多个字符
char[] chars = new char[1024];
int len =0;
while ((len = fr.read(chars)) != -1){
System.out.println(new String(chars, 0, len));
}
//3.释放资源
fr.close();
}
}FileWriter：文件字符输出流便捷类
java.io.FileWriter extends OutputStreamWriter(转换流) extends Writer
作用：把内存中的数据，以字符的方式写入到文件中
构造方法：
public FileWriter(File file)
public FileWriter(String fileName)
/* 参数：传递写入的目的地
String fileName：目的地是一个文件的路径
File file：目的地是一个文件
*/
public FileWriter(String fileName, boolean append)
public FileWriter(File file, boolean append)
/* 参数：File file|String fileName：写入数据的目的地
boolean append：续写的开关
true：可以续写，使用构造方法创建对象，文件名相同，不会创建新的文件覆盖之前同名的文件，会继续往文件的末尾写数据
false：不可以续写，使用构造方法创建对象，文件名相同，会创建一个新的空白文件覆盖之前同名的文件，在新的文件中写数据
换行：使用换行符号
Windows系统里，每行结尾是 回车 + 换行 ，即 \r\n
linux，Unix系统里，每行结尾只有 换行 ，即 \n
Mac系统里，每行结尾是 回车 ，即 \r 。从 Mac OS X开始与Linux统一
*/一个参数构造方法的作用：
1.会创建FileWriter对象
2.会根据构造方法中传递的文件|文件的路径，创建一个新的空白的文件
3.会把FileWriter对象，执向空白的文件
使用示例
使用字符输出流基本步骤：
1.创建FileWriter对象，构造方法中绑定要写入的目的地
2.使用FileWriter对象中的方法write，把数据写入到内存缓冲区中
3.使用FileWriter对象中的方法flush，把内存缓冲区中的数据刷新到文件中
4.释放资源(close方法会自动调用flush，把内存缓冲区中的数据刷新到文件中，再释放资源)
import java.io.FileWriter;
import java.io.IOException;
public class Demo01Writer {
public static void main(String[] args) throws IOException {
/*
基本使用
*/
// 1.创建FileWriter对象,构造方法中绑定要写入的目的地
FileWriter fw = new FileWriter("day21\\d.txt");
// 2.使用FileWriter对象中的方法write,把数据写入到内存缓冲区中
// void write(int c)：写出一个字符
fw.write(100);
fw.write('中'); // 中
// void write(char[] cbuf) : 写字符数组中的多个字符
char[] chars = {'a','b','c','1','2','3','中','国','@','#'};
fw.write(chars); // abc123中国@#
// abstract void write(char[] b, int off, int len)：写字符数组的一部分字符;off数组的开始索引,len写的字符个数
fw.write(chars, 6, 2); //中国
// void write(String str) ：写出一个字符串
fw.write("到中午了,我们该吃饭了");
// void write(String str, int off, int len)：写入字符串的某一部分。off字符串的开始索引,len写的字符个数
fw.write("到中午了,我们该吃饭了", 5, 6);//我们该吃饭了
// 3.使用FileWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中
//fw.flush();
// 4.释放资源(close方法会自动调用flush,把内存缓冲区中的数据刷新到文件中,再释放资源)
fw.close();
/*
字符输出流的续写和换行
*/
FileWriter fw = new FileWriter(new File("day21\\g.txt"), true);
for (int i = 1; i <= 10; i++) {
fw.write("hello" + i + "\r\n");
}
fw.close();
}
}字符转换流和读写便捷类的区别
- 字符转换流 InputStreamReader 和 OutputStreamWriter 可以指定编码，缺省 ufs-8 编码
字符读写便捷类 FileReader 和 FileWriter 不能指定编码，默认 utf-8 编码
使用 FileReader 读取 GBK 编码的文件：会出现乱码，编码和解码不一致导致。
FileReader 只能读取默认编码（UTF-8 编码）的文件
- GBK：采用的双字节编码，一个中文占用2个字节
- UTF-8：采用多字节编码，一个中文占用3个字节
缓冲流
概述
文件字节流（FileInputStream、FileOutputStream）和文件字符流（FileReader、FileWriter）这些都是计算机与硬盘之间发生的I/O 操作，基于硬盘的读写相对比较慢，读写操作收到了硬盘读取速度的限制。为了能够提高读写速度，一定程度上绕过硬盘的限制，Java提供了一种缓冲流来实现。
缓冲字节流（BufferedInputStream、BufferedOutputStream）和缓冲字符流（BufferedReader、BufferedWriter）就是先把数据缓冲在内存里，在内存中去做 IO 操作。基于内存的 IO 操作比基于硬盘的 IO 操作快很多。
缓冲流的基本原理：在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统 IO 次数，从而提高读写的效率。
BufferedInputStream：字节缓冲输入流
java.io.BufferedInputStream extends InputStream
构造方法：
public BufferedInputStream(InputStream in) // 创建一个具有默认缓冲区大小的BufferedInputStream对象
public BufferedInputStream(InputStream in, int size) // 创建具有指定缓冲区大小的 BufferedInputStream对象
/*参数：
InputStream in：传递字节输入流，可以传递InputStream的任意子类对象
可以传递FileInputStream对象，缓冲流就会给FileInputStream对象增加一个缓冲区(字节数组)
提高FileInputStream读取文件的效率
int size：指定缓冲区的大小（数组的长度），不写使用默认值（KB）
private static int DEFAULT_BUFFER_SIZE = 8192;继承自父类共性的成员方法：
int read() // 一次读取一个字节并返回
int read(byte[] b) // 使用数组缓冲，一次读取多个字节
void close() // 关闭此输入流并释放与该流关联的所有系统资源。使用示例
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Demo01BufferedInputStream {
public static void main(String[] args) throws IOException {
try(
//1.创建BufferedInputStream对象,构造方法中传递FileInputStream对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day22\\1.txt"));
){
//2.使用BufferedInputStream对象中的方法read，以字节的方式读取文件
//int read(byte[] b) 使用数组缓冲，一次读取多个字节
byte[] bytes = new byte[1024];
int len = 0;
while ((len = bis.read(bytes)) ! =-1){
System.out.println(new String(bytes, 0, len));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}BufferedOutputStream：字节缓冲输出流
java.io.BufferedOutputStream extends OutputStream
构造方法：
public BufferedOutputStream(OutputStream out) // 创建一个新的缓冲输出流，具有默认缓冲区大小
public BufferedOutputStream(OutputStream out, int size) // 创建一个新的缓冲输出流，具有指定缓冲区大小
/* 参数：
OutputStream out：传递字节输出流，可以传递OutputStream的任意子类对象
我们可以传递FileOutputStream对象，缓冲流就会给FileOutputStream对象增加一个缓冲区（字节数组）
提高FileOutputStream读取文件的效率
int size：指定缓冲区的大小（数组的长度），不写使用默认值
*/继承自父类的共性成员方法：
public void close() // 关闭此输出流并释放与此流相关联的任何系统资源
public void flush() // 刷新此输出流并强制任何缓冲的输出字节被写出
public void write(byte[] b) // 将 b.length字节从指定的字节数组写入此输出流
public void write(byte[] b, int off, int len) // 从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流
public abstract void write(int b) // 将指定的字节输出流使用示例
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo02BufferedOutputStream {
public static void main(String[] args) throws IOException {
try(
//1.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day22\\2.txt"));
){
//2.使用BufferedOutputStream对象中的方法write,把数据写入到内存缓冲区中
bos.write("你好".getBytes());
//3.使用BufferedOutputStream对象中的方法flush,把内存缓冲区中数据刷新到文件
bos.flush();
//4.释放资源(会先调用flush方法刷新数据到文件)
} catch (IOException e) {
e.printStackTrace();
}
}
}BufferedReader：字符缓冲输入流
java.io.BufferedReader extends Reader
构造方法：
public BufferedReader(Reader in) // 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
public BufferedReader(Reader in, int sz) // 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
/* 参数：
Reader in：传递字符输入流，可以传递Reader的任意的子类对象
我们可以FileReader，缓冲流就会给FileReader增加一个缓冲区
提高FileReader读取文件的效率
int sz：指定缓冲区的大小(数组长度)，不指定使用默认值
*/继承自父类的共性成员方法：
int read() // 读取单个字符。
int read(char[] cbuf) // 将字符读入数组。
void close() // 关闭该流并释放与之关联的所有资源。特有的成员方法：
String readLine() // 读取一个文本行。一次可以读取一行数据
/* 通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行(\r\n)。
返回：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null使用示例
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Demo04BufferedReader {
public static void main(String[] args) throws IOException {
try(
//1.创建BufferedReader对象,构造方法中传递FileReader对象
BufferedReader br = new BufferedReader(new FileReader("day22\\3.txt"));
){
//2.使用BufferedReader对象中的方法read|readLine，以字符的方式读取文件
//String readLine() 读取一个文本行。一次可以读取一行数据
//注意：读取的文件中有null，仅仅是一个字符串"null"，不是默认值null
String line;
while ((line = br.readLine()) != null){
System.out.println(line); //你好1你好2你好3 不会读取每行结尾的回车换行符号(行的终止符号)
}
} catch (IOException e) {
e.printStackTrace();
}
}
}BufferedWriter：字符缓冲输出流
java.io.BufferedWriter extends Writer
构造方法：
public BufferedWriter(Writer out) // 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
public BufferedWriter(Writer out， int sz) // 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
/* 参数：
Writer out：传递字符输出流，可以传递Writer的任意的子类对象
我们可以传FileWriter，缓冲流就会给FileWriter增加一个缓冲区
提高FileWriter写入文件的效率
int sz：指定缓冲区的大小(数组长度)，不指定使用默认值
*/继承自父类共性的成员方法：
abstract void close() // 关闭此输出流并释放与此流相关联的任何系统资源
abstract void flush() // 刷新此输出流并强制任何缓冲的输出字符被写出
void write(int c) // 写出一个字符
void write(char[] cbuf) // 将 b.length字符从指定的字符数组写出此输出流
abstract void write(char[] b, int off, int len) // 从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流
void write(String str) // 写出一个字符串
void write(String str, int off, int len) // 写入字符串的某一部分特有的成员方法：
void newLine() // 写入一个行分隔符。写一个换行符号，根据系统不同，而写不同的换行符号
/* Windows系统里，每行结尾是 回车+换行 ，即 \r\n
linux，Unix系统里，每行结尾只有 换行 ，即 \n
Mac系统里，每行结尾是 回车 ，即 \r 。从 Mac OS X开始与Linux统一。
*/使用示例
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Demo05BufferedWriter {
public static void main(String[] args) throws IOException {
try(
//1.创建BufferedWriter对象,构造方法中传递FileWriter对象
BufferedWriter bw = new BufferedWriter(new FileWriter("day22\\4.txt",true));
){
//2.使用BufferedWriter对象中的方法write,把数据写入到内存缓冲区中
for (int i = 1; i <= 10; i++) {
bw.write("你好"+i);
bw.newLine();//写换行
}
//3.使用BufferedWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中
bw.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
