目录：
0.IO流概述
1.字节流
2.字符流
3.IO流中的异常处理方式
4.属性集（Properties）
5.缓冲流
6.转换流
7.序列化
8.打印流
IO流概述
I:input 输入（读取）
把硬盘中的数据，读取到内存中使用
O:output 输出（写入）
把内存中的数据，写入到硬盘中保存
流; 数据（字符/字节）
1字符 = 2个字节 1字节 = 8个位
1.字节流（字节输出流与字节输入流**）
一切文件数据（文本，图片，视频等）在存储时，都是以二进制数字的形式保存
（一切皆为字节）
1.字节输出流（OutputStream）
java.io.OutputStream
这个抽象类是表示字节输出流的所有类的超类。
定义了一些子类共性的成员方法：
1.void close()
关闭此输出流并释放与此流相关联的任何系统资源。
2.void flush()
刷新此输出流并强制任何缓冲的输出字节被写出。
3.void write(byte[] b)
将 b.length字节从指定的字节数组写入此输出流。
4.void write(byte[] b, int off, int len)
从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
5.abstract void write(int b)
将指定的字节写入此输出流。
FileOutputStream：文件字节输出流
java.io.FileOutputStream extends OutputStream
作用：把内存中的数据，写入到硬盘的文件中
构造方法：
FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。
FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。
参数：
String name：目的地是一个文件的路径
File file：目的地是一个文件
构造方法的作用：
1.创建一个FileOutputStream 对象
2.会根据构造方法中传递的文件/文件路径，创建一个空的文件
3.会把FileOutputStream对象执行创建好的文件
原理：写入数据的原理（内存-》硬盘）
Java程序 -> Jvm -> OS(操作系统) -> OS调用写数据的方法 -> 把数据写入到文件中
字节输出流的使用步骤（重点）
1.创建FileOutputStream 对象 。构造方法中传递写入数据的目的地
2.调用FileOutputStream对象中的方法write，把数据写入到文件中
3.释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提供程序的效率）
public class Demo01OutputStream {
public static void main(String[] args) throws IOException {
//1.创建FileOutputStream 对象 。构造方法中传递写入数据的目的地
FileOutputStream fos = new FileOutputStream("E:\\java\\a.txt");
//2.调用FileOutputStream对象中的方法write，把数据写入到文件中
//abstract void write(int b) 将指定的字节写入此输出流。
fos.write(97);
//3.释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提供程序的效率）
//void close() 关闭此输出流并释放与此流相关联的任何系统资源。
fos.close();
}
}
一次写多个字节：
void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
如果写的第一个字节是正数（0-127），那么现实的时候会查询ASCII码表
如果写的第一个字节是负数。那么第一个字节和第二个字节，两个字节组成一个中文显示，查询系统默认码表（GBK）
FileOutputStream fos = new FileOutputStream(new File("b.txt"));
byte[] bytes = {65,66,67,68,69}; //ABCDE
fos.write(bytes)
oid write(byte[] b, int off, int len) 从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
把字节数组的一部分写入到文件中
int off：数组的开始索引
int len：写几个字节
byte[] bytes = {65,66,67,68,69};
fos.write(bytes, 0, 3); //ABC
写入字符串的方法
可以使用String类中的方法，把字符串，转换为字节数组
getBytes（） 将字符串转换为字节数组
byte[] bytes2 = “你好”.getBytes();
fos.write(bytes2); //你好
数据的续写和换行
数据的追加续写 使用两个参数的构造方法
FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。
File file/String name ： 写入数值的目的地
boolean append ： 追加写开关
true ：创建对象不会覆盖原文件，继续在文件末尾追加写数据
false：创建一个新文件，覆盖原文件
这两个构造方法，参数中都需要传递一个boolean类型的值，true表示追加数据，false表示情况原有数据。这样创建的输出流对象，就可以指定是否追加续写
写换行：写换行符号
windows： \r\n
Linux :/n
mac：\r
2.字节输入流（InputStream）
java.io.InputStream
这个抽象类是表示输入字节流的所有类的超类。
定义了一些子类共性的成员方法：
1.abstract int read() 从输入流读取数据的下一个字节。
2.int read(byte[] b, int off, int len) 从输入流读取最多 len字节的数据到一个字节数组。
3.void close() 关闭此输入流并释放与流相关联的任何系统资源。
FileInputStream:文件字节输入流
java.io.FileInputStream extends InputStream
作用：把硬盘文件中的数据，读取到内存中使用
构造方法：
1.FileInputStream(String name)
2.FileInputStream(File file)
参数：读取文件的数据源
String name：文件的路径
File file ： 文件
构造方法的作用：
1.会创建一个FileInputStream对象
2.会把FileInputStream对象指向构造方法中要读取的文件
读取数据的原理：（硬盘 - > 内存）
java程序 --> JVM -> OS ->OS读取数据的方法 -> 读取文件
字节输入流使用步骤：
1.创建FileInputStream对象 构造方法中绑定要读取的数据源
2.使用FileInputStream对象中的方法 read 读取文件
3.释放资源
public class Demo03InputStream {
public static void main(String[] args) throws IOException {
//1.创建FileInputStream对象 构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("E:\\java\\a.txt");
//2.使用FileInputStream对象中的方法 read 读取文件
//int read() 读取文件中的一个字节并返回，读取到文件的末尾返回-1
/*int len = fis.read();
System.out.println(len); //97 a
len = fis.read();
System.out.println(len);//98 b
len = fis.read();
System.out.println(len);//99 c
len = fis.read();
System.out.println(len);//100 d
len = fis.read();
System.out.println(len);//-1 没有
*/
/*
* len = fis.read();读取到一个字节，并返回给len
* len == -1 判断len是否读到末尾 末尾len返回-1
*
* */
System.out.println("代码优化");
int len = 0; //记录读取到的字节
while(true) {
len = fis.read();
if (len == -1) {
System.out.println("读取完毕");
break;
}
System.out.print((char)len); //abcd
}
//3.释放资源
fis.close();
}
}
一次读取多个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区 b 中。
前提：明确两件事情：
1.方法的参数byte[] 的作用
起到缓冲作用，存储每次读取到的多个字节
数组的长度一般定义为1024（1kb） 或者 1024的整数倍
2.方法的返回值是什么
每次读取的有效字节数
Object类中的两个构造方法
String(byte[] bytes) 把字节数组转换为字符串
String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串
offset：数组的开始索引
length：数组转换的个数
public class Demo04InputStream {
public class Demo04InputStream {
public static void main(String[] args) throws IOException {
//1.创建FileInputStream对象 构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("E://java//a.txt");
byte[] bs = new byte[1024]; //存储读取到的多个字节
int len = 0; //记录每次读取到的有效字节个数
while((len = fis.read(bs))!=-1) {
System.out.println(new String(bs,0,bs.length));
}
//3.释放资源
fis.close();
}
}
图片的复制案例
文件的复制：一读一写
明确：1.数据源：E:\java\1.jpg 2.数据的目的地：E:\java\2.jpg
文件复制的步骤
1.创建一个字节流输入对象，构造方法中绑定要读取的数据源
2.创建一个字节流输出对象，构造方法中绑定要写入的目的地
3.使用字节输入流对象中的read方法，读取文件
4.使用字节输出流中的write方法，把读取到的字节写入到目的地的文件中
5.释放资源
public class Test图片复制 {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis(); //程序开始时间
//1.创建一个字节流输入对象，构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("E:\\java\\1.jpg"); //要读取的图片的位置
//2.创建一个字节流输出对象，构造方法中绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("E:\\java\\2.jpg");//要存储的图片的位置
//读取一个字节写入一个字节的方法
/*int len = 0;
//3.使用字节输入流对象中的read方法，读取文件
while((len = fis.read()) != -1) {
//4.使用字节输出流中的write方法，把读取到的字节写入到目的地的文件中
fos.write(len);
}*/
//使用字节缓冲，读取多个字节，写入多个字节
byte[] bytes = new byte[1024];
int len = 0;
while((len = fis.read(bytes)) != -1) {
fos.write(bytes,0,bytes.length);
}
//5.释放资源 先关闭写的流 再关闭读的流
fis.close();
fos.close();
long e = System.currentTimeMillis();
System.out.println("程序一共耗时："+(e-s)+"毫秒");
}
}
2.字符流(字符输入流与字符输出流)
当使用字节流读取文件文件夹时，可能会有一个小问题，就是遇见中文字符时，可能不会显示完整的字符，原因是一个中文字符可能占多个字节存储
**GBK:**占用两个字节
UTF-8：占用三个字节
1.字符输入流（Reader）
java.io.Reader
java.io.FileReader extends java.io.InputStreamReader extends java.io.Reader
java.io.Reader 字符输入流：是字符输入流的最顶层的父类（抽象类）
作用：把硬盘文件中的数据以字符的方法读取到内存中
定义了一些共性的成员方法方法：
1.int read() 读一个字符 并返回
2.int read(char[] cbuf) 一次读取多个字符，将字符读入数组
3.void close() 关闭流并释放与之相关联的任何系统资源。
构造方法：
1.FileReader(String fileName) 创建一个新的 FileReader ，给定要读取的文件的名称。
2.FileReader(File file) 创建一个新的 FileReader ，给出 File读取。
参数：读取文件的数据源
fileName：文件的路径
file：一个文件
构造方法的作用：
1.创建一个FileReader对象
2.会把FileReader对象执行要读取的文件
字符输入流的使用步骤
1.创建一个FileReader对象，构造方法中绑定要读取的数据源
2.使用FileReader 对象中的方法，read读取文件
3.释放资源
读取字符数据
String类的构造方法：
String(char[] value) 把字符数组转换为字符串
String(char[] ,int offset , int count) 把字符数组的一部分转换为字符串
读取一个字符
while((len=fr.read()) != -1) {
System.out.print((char)len);//饶阳军
}
一次性读取多个字符
int len = 0; //记录每次读取的有效字符个数
char[] chars = new char[1024]; //chars 存储读取到的多个字符
while((len = fr.read(chars)) != -1) {
System.out.print(new String(chars,0,len));//饶阳军
}
public class Demo05Reader {
public static void main(String[] args) throws IOException {
//1.创建一个FileReader对象，构造方法中绑定要读取的数据源
FileReader fr = new FileReader("E:\\java\\a.txt");
//int len = 0;
//2.使用FileReader 对象中的方法，read读取文件
/*while((len=fr.read()) != -1) {
System.out.print((char)len);//饶阳军
}*/
int len = 0; //记录每次读取的有效字符个数
char[] chars = new char[1024]; //chars 存储读取到的多个字符
while((len = fr.read(chars)) != -1) {
System.out.print(new String(chars,0,len));//饶阳军
}
//3.释放资源
fr.close();
}
}
2.字符输出流（Writer）
java.io.Writer 抽象类,用于写出字符流的所有类的超类
定义了共性的成员方法：
1.void write(int c) 写一个字符
2.void write(char[] cbuf) 写入一个字符数组。
3.abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
4.void write(String str) 写一个字符串
5.void write(String str, int off, int len) 写一个字符串的一部分。
6.abstract void flush() 刷新该流的缓冲。
7.abstract void close() 关闭流，必须先刷新。
FileWriter：文件字符输出流
java.io.FileWriter extends java.io.OutputStreamWriter extends java.io.Writer
作用：把内存中的字符数据，写入到文件中
构造方法：
FileWriter(File file) 给一个File对象构造一个FileWriter对象。
FileWriter(String fileName) 构造一个给定文件名的FileWriter对象。
参数：写入数据的目的地
fileName：文件的路径
file：是一个文件
构造方法的作用：
1.创建一个FileWriter对象
2.会根据构造方法中传递的文件/文件的路径，创建文件
3.会把FileWirter对象指向创建好的文件
字符输出流的使用步骤：
1.创建一个FileWriter对象，构造方法中绑定要写入数据的目的地
2.使用FileWriter的方法write 把数据写入到内存缓冲区中（字符转换为字节的过程）
3.使用FileWriter的方法flush，把内存缓冲区中的数据，刷新到文件中
4.释放资源（会先把内存缓冲区中的数据刷新到文件中）
关闭close（）和刷新flush（）
如果我们既想写出数据，又想继续使用流，那么需要使用flush 方法
flush 刷新缓冲区，流对象可以继续使用
close 先刷新缓冲区，然后通知系统释放资源，流对象无法继续使用
public class Demo06Writer {
public static void main(String[] args) throws IOException {
//1.创建一个FileWriter对象，构造方法中绑定要写入数据的目的地
FileWriter fw = new FileWriter("E://java//b.txt");
//2.使用FileWriter的方法write 把数据写入到内存缓冲区中（字符转换为字节的过程）
fw.write(97);
//3.使用FileWriter的方法flush，把内存缓冲区中的数据，刷新到文件中
// fw.flush();
//4.释放资源（会先把内存缓冲区中的数据刷新到文件中）
fw.close();
}
}
字符输出流写数据的其他方法
字符数组、字符串等写入
2.void write(char[] cbuf) 写入一个字符数组。
3.abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
4.void write(String str) 写一个字符串
5.void write(String str, int off, int len) 写一个字符串的一部分。
public class Demo07Writer {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("E:\\java\\c.txt");
//2.void write(char[] cbuf) 写入一个字符数组。
char[] chars = {'c','d','e','f'};
fw.write(chars); //写入字符数组//cdef
//3.abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
fw.write(chars, 0, 3); //cdefcde
//4.void write(String str) 写一个字符串
fw.write("hello world");
//5.void write(String str, int off, int len) 写一个字符串的一部分。
fw.write("饶阳军大帅哥",3,3);//大帅哥
fw.close();
}
}
续写与换行
续写，追加写：使用两个参数的构造方法
FileWriter(String Name,boolean append);
FileWriter(File file,boolean append);
参数：
String Name String Name：写入数据的目的地
boolean append：续写的开关。
true：不会创建新的文件，覆盖原文件，可以续写
false：创建新的文件，覆盖掉原文件
换行符号：
Windows：\r\n
linux:/n
Mos:/r
3.IO流中的异常处理方式
除了Throws抛出之外，我们还可以使用JDK7 与JDK8对IO流异常处理的新特性
try…catch处理流中的异常
Jdk1.7之前 使用try…catch finally 处理流中的异常
格式：
try{
//可能会产生异常的代码
}catch（异常类的变量）{
//异常的处理逻辑
}finally{
//一定会执行的代码
资源释放
}
Jdk7 和Jdk9流中的异常处理
1.JDK7的新特性：
在try的后面可以增加一个（），在括号中可以定义流对象
那么这个流对象的作用域就在try中有效
try中的代码执行完毕，会自动把流对象释放，不用写finally
格式：
try(定义流对象；定义流对象；...){
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
public class Demo09IOexception2 {
public static void main(String[] args) {
try(FileInputStream fis = new FileInputStream("E:\\java\\c.txt");
FileOutputStream fos = new FileOutputStream("E:\\java\\d.txt")) {
//可能会产生异常的代码
int len = 0;
while((len = fis.read())!=-1) {
fos.write(len);
}
} catch (Exception e) {
//异常的处理逻辑
e.printStackTrace();
}
}
}
2.JDK9的新特性：
try的前面可以定义流对象
在try的后面（）中可以直接引入流对象的名称（变量名）
在try代码块执行完毕之后，流对象也可以释放掉，不用写finally
格式：
A a = new A();
B b = new B();
try(a;b){
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
public class Demo09IOexception3 {
public static void main(String[] args) throws FileNotFoundException {
FileInputStream fis = new FileInputStream("E:\\java\\c.txt");
FileOutputStream fos = new FileOutputStream("E:\\java\\e.txt");
try(fis;fos) {
//可能会产生异常的代码
int len = 0;
while((len = fis.read())!=-1) {
fos.write(len);
}
} catch (Exception e) {
//异常的处理逻辑
e.printStackTrace();
}
}
}
4.属性集（Properties）
概述
Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。
java.util.Properties集合 extends Hashtable<K,V> implements Map<K,V>
Properties集合是一个唯一与IO流相结合的集合
可以使用 Properties集合中的方法store ，把集合中的临时数据，持久化写入到硬盘中存储
可以使用Properties集合中的方法load 把硬盘中保存的文件（键值对），读取到集合中使用
属性列表中的每个键及其对应的值都是一个字符串。
Properties集合是一个双列集合，key和value 默认都是字符串
操作字符串的特有方法
1.Object setProperty(String key, String value) 调用Hashtable 的 方法put
2.String getProperty(String key) 通过Key 找到Value值 此方法相当于Map集合中的get（key）方法
3.Set stringPropertyNames() 返回此属性列表中的键集，其中键及其对应的值为字符串，此方法相当于Map集合中的keyset方法
遍历取出Properties集合中的数据
private static void show01() {
//1.创建一个Properties集合对象
Properties prop = new Properties(); //泛型默认字符串
//2.使用setProperty方法 往集合中添加数据
prop.setProperty("赵丽颖", "168");
prop.setProperty("迪丽热巴", "165");
prop.setProperty("马尔扎哈", "161");
//3.使用stringPropertyNames 把Properties集合中的key取出，存储到一个set集合中
Set<String> strings = prop.stringPropertyNames();
//遍历set集合,取出Properties集合的每一个键的值
for (String string : strings) {
//使用getProperty(String key)方法 通过键获取值
String value = prop.getProperty(string);
System.out.println(value);
}
}
Properties 集合中的Stroe方法
把集合中的临时数据，持久化写入到硬盘中存储
两种使用方法
1.void store(OutputStream out, String comments)
2.void store(Writer writer, String comments)
参数：
OutputStream out：字节输出流，不能写入中文
Writer writer：字符输出流，可以写中文
String comments：注释：用来解释说明保存的文件是做什么用的，不能使用中文，会产生乱码默认的是Unicode编码 一般使用“” 空字符串
使用步骤：
1.创建一个Properties集合对象，添加数据
2.创建字节输出流/字符输出流对象。构造方法中绑定我们要输出的目的地
3.使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
4.释放资源
private static void show02() throws IOException {
//1.创建一个Properties集合对象，添加数据
Properties prop = new Properties();
prop.setProperty("赵丽颖", "168");
prop.setProperty("迪丽热巴", "165");
prop.setProperty("马尔扎哈", "161");
//2.创建字节输出流/字符输出流对象。构造方法中绑定我们要输出的目的地
FileWriter fw = new FileWriter("E:\\java\\prop.txt");
//3.使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
prop.store(fw, "save data");
//4.释放资源
fw.close();
}
Properties 集合中的load方法
可以使用 Properties集合中的方法load ，把硬盘中保存的文件（键值对），读取到集合中使用
void load(InputStream inStream)
void load(Reader reader)（一般都采用字符输入流）
参数：
InputStream inStream 字节输入流，不能读取含有中文的键值对
Reader reader 字符输入流 能读取含有中文的键值对
使用步骤:
1.创建一个Properties集合对象
2.使用Properties集合对象中的方法load读取保存键值对的文件
3.遍历Properties集合
注意：
1.存储键值对的文件中，键与值默认的连接符号可以使用= 空格（其他符合）
2.存储键值对的文件中，可以使用#进行注释，被注释的键值对不会再被读取
3.存储键值对的文件中，键与值默认都是字符串，不用再加引号了
Properties可以把集合中的数据保存到流中或从流中加载。
private static void show03() throws IOException {
//1.创建一个Properties集合对象
Properties prop = new Properties();
//2.使用Properties集合对象中的方法load读取保存键值对的文件
prop.load(new FileReader("E:\\java\\prop.txt"));
//3.遍历Properties集合
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
String value = prop.getProperty(key);
System.out.println("Key:"+key+"Value"+value);
}
}
5.缓冲流
更强大的流是在基本的流对象基础上创建而来的，能够高效率读写的流，
能够转换编码的转换流，能够持久化存储对象的序列化流等等
缓冲流的原理：
给基本的输入流增加一个缓存区（其实就是数组） 提高基本的字节输入流的读取效率
就是在创建流的对象是，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率
缓冲流：也称高效流，是对4个基本的FileXxx流的增强，所以也是4个流
1.字节缓冲流：BufferedInputStream ， BufferedOutputStream
1.BufferedOutputStream:字节缓冲输出流
java.io.BufferedOutputStream extends java.io.OutputStream
继承自父类的共性成员方法：
void close() 关闭此输出流并释放与此流相关联的任何系统资源。
void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。
void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
void write(byte[] b, int off, int len) 从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
abstract void write(int b) 将指定的字节写入此输出流。
构造方法：
BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。
参数：
OutputStream out ： 字节输出流
可以传递FileOutputStream 缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率
int size ：指定缓冲流内部缓冲区的大小，不指定就默认
使用步骤
1.创建一个FileOutputStream对象，构造方法中绑定我们要输出的目的地
2.创建一个BufferedOutputStream 构造方法中传递OutputStream对象，提高FileOutputStream对象效率
3.使用BufferedOutputStream对象中的方法 write，把数据写入到内部缓冲区中
4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区的数据，刷新到文件中
5.释放资源（会先调用flush方法刷新数据，第四步方法可以省略）
public class Demo01 {
public static void main(String[] args) throws IOException {
//1.创建一个FileOutputStream对象，构造方法中绑定我们要输出的目的地
FileOutputStream fos = new FileOutputStream("E:\\java\\buffer.txt");
//2.创建一个BufferedOutputStream 构造方法中传递OutputStream对象，提高FileOutputStream对象效率
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3.使用BufferedOutputStream对象中的方法 write，把数据写入到内部缓冲区中
bos.write("我把数据写入到内部缓冲区中".getBytes());
bos.close();
}
}
2.BufferedInputStream:字节缓冲输入流
java.io.BufferedInputStream extends java.io.InputStream
继承自父类的成员方法：
int read() 从输入流读取数据的下一个字节。
int read(byte[] b, int off, int len) 从输入流读取最多 len字节的数据到一个字节数组。
void close() 关闭此输入流并释放与流相关联的任何系统资源。
构造方法：
BufferedInputStream(InputStream in) 创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
BufferedInputStream(InputStream in, int size) 创建 BufferedInputStream具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用
参数：InputStream in 字节输入流
我们可以传递FileInputStream，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率
int size：指定缓冲区大小 不写默认
使用步骤：
1.创建一个FileInputStream对象，构造方法中传递要读取的数据源
2.创建一个BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的读取效率
3.使用BufferedInputStream对象中的read 读取文件
4.释放资源
public class Demo02 {
public static void main(String[] args) throws IOException {
//1.创建一个FileInputStream对象，构造方法中传递要读取的数据源
FileInputStream fis =new FileInputStream("E:\\java\\buffer.txt");
//2.创建一个BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的读取效率
BufferedInputStream bfi = new BufferedInputStream(fis);
//3.使用BufferedInputStream对象中的read 读取文件
//int read() 读取一个字节
/*int len = 0;
while((len = bfi.read()) != -1) {
System.out.print((char)len);
}*/
//int read(byte[] b)一次读取多个字节
int len = 0;//记录每次读取的有效字节个数
byte[] chars = new byte[1024];//存储每次读取的数据
while((len = bfi.read(chars)) != -1) {
System.out.println(new String(chars,0,len));
}
//4.释放资源
bfi.close(); //关闭缓冲流 会自动关闭字节流
}
}
Test：使用缓冲流复制大文件
文件复制的步骤：
1.创建字节缓冲输入流对象，构造方法中传递字节输入流
2.创建字节缓冲输出流对象，构造方法中传递字节输出流
3.使用字节缓冲输入流对象的方法 read 读取文件
4.使用字节缓冲输出流对象的方法 write 把读取文件的数据写入到内部缓冲区
5.是否资源（会先把缓冲区的数据，刷新到文件中）
public class BufferTest {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis(); //获取程序开始的毫秒值
FileInputStream fis = new FileInputStream("C:\\Java\\jdk-9\\lib\\modules");//需要复制的文件
FileOutputStream fos = new FileOutputStream("E:\\java\\copymodules"); //复制到的路径
BufferedInputStream bis = new BufferedInputStream(fis); //字节输入缓冲流
BufferedOutputStream bos = new BufferedOutputStream(fos);//字节缓冲输出流
int len = 0;
byte[] bytes = new byte[1024];
while((len = bis.read(bytes)) != -1) {
bos.write(bytes,0,len);
}
bis.close();
bos.close();
long e = System.currentTimeMillis();//获取程序结束的毫秒值
System.out.println("复制文件一共使用"+(e-s)+"毫秒");//复制文件一共使用889毫秒
}
}
字符缓冲流：BufferedReader ， BufferedWriter
1.BufferedReader：字符缓冲输入流
java.io.BufferedReader extends java.io.Reader
继承子父类的共性成员方法
1.int read() 读一个字符 并返回
2.int read(char[] cbuf) 一次读取多个字符，将字符读入数组
3.void close() 关闭流并释放与之相关联的任何系统资源。
构造方法：
BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。
参数：
1.Reader in 字符输入流
我们可以传递FileReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率
2.int sz
指定大小的输入缓冲区，不写默认指定大小
特有的方法：
String readLine() 读一行文字。 读取一行的文本
行的终止符号：一行被视为由换行符（’\ n’），回车符（’\ r’）中的任何一个或随后的换行符（"\r\n"）终止。
返回值： 包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null
使用步骤：
1.创建字符缓冲输入流对象，构造方法中传递字符输入流
2.使用字符缓冲输入流对象的方法read/readLine 读取文本
3.释放资源
public class Demo03Reader {
public static void main(String[] args) throws IOException {
//1.创建字符缓冲输入流对象，构造方法中传递字符输入流
BufferedReader br = new BufferedReader(new FileReader("E:\\java\\e.txt"));
//2.使用字符缓冲输入流对象的方法read/readLine 读取文本
/*int len = 0;
while ((len = br.read()) != -1) {
System.out.println(len);
}*/
String string;
while ((string = br.readLine()) != null) {
System.out.println(string);
}
br.close();
}
}
2.BufferedWrite：字符缓冲输出流
java.io.BufferedWriter extends java.io.Writer
继承子父类的共性成员方法
1.void write(int c) 写一个字符
2.void write(char[] cbuf) 写入一个字符数组。
3.abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
4.void write(String str) 写一个字符串
5.void write(String str, int off, int len) 写一个字符串的一部分。
6.abstract void flush() 刷新该流的缓冲。
7.abstract void close() 关闭流，必须先刷新。
构造方法：
1.BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
2.BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
参数：
1.Writer out：字符输出流
我们可以传递FilerWriter， 缓冲流会给FilerWriter 增加一个缓冲区，提高FilerWriter的写入效率
2.int sz
指定缓冲区的大小。不写：默认大小
特有的成员方法：
void newLine() 写一行行分隔符。 会根据不同的操作系统，获取不同的行分隔符
换行：换行分隔符
Windows： \r\n
Linux:/n
Moc：/r
使用步骤：
1.创建一个字符缓冲输出流，构造方法中传递 字符输出流
2.调用字符缓冲流中的方法writer，把数据写入到内存缓冲区中
3.调用字符缓冲流中的方法flush，把内存缓冲区的数据 刷新到内存
4.释放资源
public class Demo04Writer {
public static void main(String[] args) throws IOException {
//1.创建一个字符缓冲输出流，构造方法中传递 字符输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\java\\e.txt"));
//2.调用字符缓冲流中的方法writer，把数据写入到内存缓冲区中
for (int i = 0; i < 10; i++) {
bw.write("饶阳军大帅哥");
bw.newLine(); //换行
}
bw.close();
}
}
Test：对文档内容进行排序
分析：
1.创建一个Hashmap 集合 Key存储每行文本的需要（1.2.3） value 存储每行的文本
2.创建字节缓冲输入流对象 构造方法中绑定字符输入流
3.穿件字符缓冲输出流对象 构造方法中绑定字符输出流
4.使用字符缓冲输入流对象的方法 readline()
5.对读取到的文本进行切割获取行中的序号 和文本的内容
6.切割好的序号和文本存储到Hashmap 集合中（Key需要是有序的 会自动排序1 ， 2 ，3）
7.遍历集合 获取每一个键值对
8.把每一个对拼接成一个文本行
9.把拼接好的文本 使用字符缓冲输出流的write方法 写入到文件中
10.释放资源
public class BufferTest02 {
public static void main(String[] args) throws IOException {
//1.创建一个Hashmap 集合 Key存储每行文本的需要（1.2.3） value 存储每行的文本
HashMap<String, String> map = new HashMap<>();
//2.创建字节缓冲输入流对象 构造方法中绑定字符输入流
BufferedReader br = new BufferedReader(new FileReader("E:\\java\\e.txt"));
//3.穿件字符缓冲输出流对象 构造方法中绑定字符输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\java\\e2.txt"));
String len;
while ((len=br.readLine())!= null) {//4.使用字符缓冲输入流对象的方法 readline()
String[] strings = len.split("\\.");//5.对读取到的文本进行切割获取行中的序号 和文本的内容 使用转义字符\\. 代表.
map.put(strings[0], strings[1]);//6.切割好的序号和文本存储到Hashmap 集合中（Key需要是有序的 会自动排序1 ， 2 ，3）
}
//7.遍历集合 获取每一个键值对
Set<String> keys = map.keySet();
for (String key : keys) {
//8.把每一个对拼接成一个文本行
String value = map.get(key);
//9.把拼接好的文本 使用字符缓冲输出流的write方法 写入到文件中
bw.write(key+"."+value);
bw.newLine(); //写一个换行
}
//10.释放资源
br.close();
bw.close();
}
}
94
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
