IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。如下图所示
把数据从磁盘、网络中读取到程序中来，用到的是输入流。
把程序中的数据写入磁盘、网络中，用到的是输出流。
简单记：输入流（读数据）、输出流（写数据）
IO流在Java中有很多种，不同的流来干不同的事情。Java把各种流用不同的类来表示，这些流的继承体系如下图所示：
IO流分为两大派系：
1.字节流：字节流又分为字节输入流、字节输出流
2.字符流：字符流由分为字符输入流、字符输出流
字节流
FileInputStream读取一个字节
节流中的字节输入流，使用InputStream来表示。但是InputStream是抽象类，我们用的是它的子类，叫FileInputStream。
需要用到的方法如下图所示：有构造方法、成员方法：
| 构造方法 | 描述 |
|---|---|
FileInputStream(File file) | 创建一个新的 FileInputStream 对象，用于从指定文件读取字节数据。 |
FileInputStream(String fileName) | 创建一个新的 FileInputStream 对象，用于从指定文件名的文件读取字节数据。 |
| 方法 | 描述 |
|---|---|
int read() | 读取单个字节的数据。 |
int read(byte[] b) | 从输入流中读取字节数组的数据，并将读取的字节数据存储到指定的字节数组中。 |
int read(byte[] b, int off, int len) | 从输入流中读取字节数组的数据，并将读取的字节数据存储到指定的字节数组的指定位置开始的部分中。 |
long skip(long n) | 跳过指定数量的字节。 |
void close() | 关闭输入流。 |
使用FileInputStream读取文件中的字节数据，步骤如下：
第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read()方法开始读取文件的字节数据。
第三步：调用close()方法释放资源
代码如下：
public static void main(String[] args) {
try {
// 1、创建文件字节输入流管道，与源文件接通。
FileInputStream inputStream = new FileInputStream("day17IO/data/data.txt");
// 2、开始读取文件的字节数据。
// public int read():每次读取一个字节返回，如果没有数据了，返回-1.
int temp; // 用于记住读取的字节。
while ((temp = inputStream.read()) != -1) {
System.out.print((char) temp);
}
// 3、流使用完毕之后，必须关闭！释放系统资源！
inputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
这里需要注意一个问题：由于一个中文在UTF-8编码方案中是占3个字节，采用一次读取一个字节的方式，读一个字节就相当于读了1/3个汉字，此时将这个字节转换为字符，是会有乱码的。
FileInputStream读取多个字节
FileInputStream调用read()方法，可以一次读取一个字节。但是这种读取方式效率太太太太慢了。 为了提高效率，我们可以使用另一个read(byte[] bytes)的重载方法，可以一次读取多个字节，至于一次读多少个字节，就在于你传递的数组有多大。
使用FileInputStream一次读取多个字节的步骤如下：
第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read(byte[] bytes)方法开始读取文件的字节数据。
第三步：调用close()方法释放资源
代码如下：
public static void main(String[] args) {
try {
// 1、创建文件字节输入流管道，与源文件接通。
FileInputStream inputStream = new FileInputStream("day17IO/data/data.txt");
// 2、开始读取文件中的字节数据：每次读取多个字节。
// public int read(byte b[]) throws IOException
// 每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.
byte[] buffer = new byte[3];
// 记住每次读取了多少个字节
int len;
while ((len = inputStream.read(buffer)) != -1) {
// 注意：读取多少，倒出多少。
String rs = new String(buffer, 0 , len);
System.out.print(rs);
}
// 3、流使用完毕之后，必须关闭！释放系统资源！
inputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
需要我们注意的是：read(byte[] bytes)它的返回值，表示当前这一次读取的字节个数。
假设有一个a.txt文件如下：
aaa
每次读取过程如下：
也就是说，并不是每次读取的时候都把数组装满，比如数组是 byte[] bytes = new byte[3];
第一次调用read(bytes)读取了3个字节(分别是97,98,99)，并且往数组中存，此时返回值就是3
第二次调用read(bytes)读取了2个字节(分别是99,100),并且往数组中存，此时返回值是2
第三次调用read(bytes)文件中后面已经没有数据了，此时返回值为-1
还需要注意一个问题：采用一次读取多个字节的方式，也是可能有乱码的。因为也有可能读取到半个汉字的情况。
FileInputStream读取全部字节
不管是一次读取一个字节，还是一次读取多个字节，都有可能有乱码。我们可以一次性读取文件中的全部字节，然后把全部字节转换为一个字符串，就不会有乱码了。
public static void main(String[] args) {
try {
// 1、创建文件字节输入流管道，与源文件接通。
FileInputStream inputStream = new FileInputStream("day17IO/data/data.txt");
// 2、准备一个字节数组，大小与文件的大小正好一样大。
int length = (int) new File("day17IO/data/data.txt").length();
byte[] buffer = new byte[length];
int rs = inputStream.read(buffer);
System.out.println(rs);
System.out.println(new String(buffer));
// 3、流使用完毕之后，必须关闭！释放系统资源！
inputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
try {
// 1、创建文件字节输入流管道，与源文件接通。
FileInputStream inputStream = new FileInputStream("day17IO/data/data.txt");
//2、调用方法读取所有字节，返回一个存储所有字节的字节数组。
byte[] bytes = inputStream.readAllBytes();
System.out.println(new String(bytes));
// 3、流使用完毕之后，必须关闭！释放系统资源！
inputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
最后，还是要注意一个问题：一次读取所有字节虽然可以解决乱码问题，但是文件不能过大，如果文件过大，可能导致内存溢出。
FileOutputStream写字节
往文件中写数据需要用到OutputStream下面的一个子类FileOutputStream。写输入的流程如下图所示
| 构造方法 | 描述 |
|---|---|
FileOutputStream(File file) | 创建一个新的 FileOutputStream 对象，用于向指定文件写入字节数据。 |
FileOutputStream(File file, boolean append) | 创建一个新的 FileOutputStream 对象，用于向指定文件追加字节数据。 |
FileOutputStream(String fileName) | 创建一个新的 FileOutputStream 对象，用于向指定文件名的文件写入字节数据。 |
FileOutputStream(String fileName, boolean append) | 创建一个新的 FileOutputStream 对象，用于向指定文件名的文件追加字节数据。 |
| 方法 | 描述 |
|---|---|
void write(int b) | 将指定的字节写入输出流。 |
void write(byte[] b) | 将字节数组的数据写入输出流。 |
void write(byte[] b, int off, int len) | 将字节数组的一部分数据写入输出流。 |
void flush() | 刷新输出流，将缓冲区中的数据写入到输出设备中。 |
void close() | 关闭输出流。 |
使用FileOutputStream往文件中写数据的步骤如下：
第一步：创建FileOutputStream文件字节输出流管道，与目标文件接通。
第二步：调用wirte()方法往文件中写数据
第三步：调用close()方法释放资源
代码如下：
public static void main(String[] args) {
try {
// 1、创建一个字节输出流管道与目标文件接通。
// 覆盖管道：覆盖之前的数据
// FileOutputStream fileOutputStream = new FileOutputStream("day17IO/data/data.txt");
// 追加数据的管道
FileOutputStream fileOutputStream = new FileOutputStream("day17IO/data/data.txt",true);
// 2、开始写字节数据出去了
fileOutputStream.write('\n');
fileOutputStream.write(97);
fileOutputStream.write('b');
fileOutputStream.write('磊'); // 默认只能写出去一个字节，会乱码
fileOutputStream.write('\n');
byte[] bytes = "test".getBytes();
fileOutputStream.write(bytes);
fileOutputStream.write('\n');
fileOutputStream.write(bytes,0,2);
// 3、流使用完毕之后，必须关闭！释放系统资源！
fileOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
字节流复制文件
如我们要复制一张图片，从磁盘D:/resource/OIP.png的一个位置，复制到C:/data/OIP.png位置。
复制文件的思路如下图所示：
1.需要创建一个FileInputStream流与源文件接通，创建FileOutputStream与目标文件接通
2.然后创建一个数组，使用FileInputStream每次读取一个字节数组的数据，存如数组中
3.然后再使用FileOutputStream把字节数组中的有效元素，写入到目标文件中
代码如下：
public static void main(String[] args) {
// 目标：使用字节流完成对文件的复制操作。
try {
// 1、创建一个字节输入流管道与源文件接通。
FileInputStream inputStream = new FileInputStream("day17IO/src/main/resources/OIP.jpg");
// 2、创建一个字节输出流管道与目标文件接通。
FileOutputStream fileOutputStream = new FileOutputStream("day17IO/data/OIP.jpg");
// 3、创建一个字节数组，负责转移字节数据。
int length = (int) new File("day17IO/src/main/resources/OIP.jpg").length();
byte[] buffer = new byte[length];
// 4、从字节输入流中读取字节数据，写出去到字节输出流中。
int num = inputStream.read(buffer, 0, length);
System.out.println("文件字节长度：" + num);
for (byte b : buffer) {
fileOutputStream.write(b);
}
inputStream.close();
fileOutputStream.close();
System.out.println("复制完成！！");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
IO资源的释放
JDK7以前的资源释放
在JDK7版本以前，我们可以使用try…catch…finally语句来处理。格式如下：
try{
//有可能产生异常的代码
}catch(异常类 e){
//处理异常的代码
}finally{
//释放资源的代码
//finally里面的代码有一个特点，不管异常是否发生，finally里面的代码都会执行。
}
JDK7以后的资源释放
使用try…catch…finally处理异常，并释放资源代码比较繁琐。Java在JDK7版本为我们提供了一种简化的是否资源的操作，它会自动是否资源。代码写起来也想当简单。
try(资源对象1; 资源对象2;){
使用资源的代码
}catch(异常类 e){
处理异常的代码
}
//注意：注意到没有，这里没有释放资源的代码。它会自动是否资源
代码如下：
public static void main(String[] args) {
try ( FileInputStream fileInputStream = new FileInputStream("day17IO/data/data.txt")){
byte[] bytes = fileInputStream.readAllBytes();
System.out.println(new String(bytes));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
字符流
使用字节流可以读取文件中的字节数据。但是如果文件中有中文，使用字节流来读取，就有可能读到半个汉字的情况，这样会导致乱码。
所以Java专门为我们提供了另外一种流，叫字符流，可以字符流是专门为读取文本数据而生的。
FileReader类
字符流中的FileReader类，这是字符输入流，用来将文件中的字符数据读取到程序中来。
FileReader读取文件的步骤如下：
第一步：创建FileReader对象与要读取的源文件接通
第二步：调用read()方法读取文件中的字符
第三步：调用close()方法关闭流
需要用到的方法：先通过构造器创建对象，再通过read方法读取数据（注意：两个read方法的返回值，含义不一样）
| 构造方法 | 描述 |
|---|---|
FileReader(File file) | 创建一个新的 FileReader 对象，用于读取指定文件的字符数据。 |
FileReader(String fileName) | 创建一个新的 FileReader 对象，用于读取指定文件名的文件的字符数据。 |
| 方法 | 描述 |
|---|---|
int read() | 读取单个字符的数据。 |
int read(char[] cbuf) | 将字符数据读入字符数组中。 |
int read(char[] cbuf, int off, int len) | 将字符数据读入指定位置的字符数组中。 |
void close() | 关闭字符输入流。 |
public static void main(String[] args) throws IOException {
// 1、创建一个文件字符输入流管道与源文件接通
FileReader fileReader = new FileReader("day17IO/data/data.txt");
// 2、读取数据
// 2.1、一个字符一个字符的读
int temp;
while ((temp = fileReader.read())!= -1) {
System.out.print((char) temp);
}
// 2.2、每次读取多个字符
char[] buffer = new char[2];
int len;
while ((len = fileReader.read(buffer)) != -1) {
System.out.print(new String(buffer, 0, len));
}
// 3、关闭管道
fileReader.close();
}
FileWriter类
FileWriter类，它可以将程序中的字符数据写入文件。
FileWriter往文件中写字符数据的步骤如下：
第一步：创建FileWirter对象与要读取的目标文件接通
第二步：调用write(字符数据/字符数组/字符串)方法读取文件中的字符
第三步：调用close()方法关闭流
需要用到的方法如下：构造器是用来创建FileWriter对象的，有了对象才能调用write方法写数据到文件。
| 构造方法 | 描述 |
|---|---|
FileWriter(File file) | 创建一个新的 FileWriter 对象，用于向指定文件写入字符数据。 |
FileWriter(String fileName) | 创建一个新的 FileWriter 对象，用于向指定文件名的文件写入字符数据。 |
FileWriter(File file, boolean append) | 创建一个新的 FileWriter 对象，用于向指定文件追加字符数据。 |
FileWriter(String fileName, boolean append) | 创建一个新的 FileWriter 对象，用于向指定文件名的文件追加字符数据。 |
| 方法 | 描述 |
|---|---|
void write(String str) | 将指定的字符串写入字符输出流。 |
void write(char[] cbuf) | 将字符数组写入字符输出流。 |
void write(char[] cbuf, int off, int len) | 将字符数组的一部分写入字符输出流。 |
void flush() | 刷新字符输出流，将缓冲区中的数据写入到输出流中。 |
void close() | 关闭字符输出流。 |
public static void main(String[] args) throws IOException {
// 1、创建一个文件字符输出流管道与目标文件接通，第二个参数可以设置为数据为追加
// FileWriter fileWriter = new FileWriter("day17IO/data/data.txt"); // 覆盖数据
FileWriter fileWriter = new FileWriter("day17IO/data/data.txt", true); // 追加数据
// 2、写入数据
// 2.1、写入一个字符
fileWriter.write('\n');
fileWriter.write('c');
fileWriter.write('\n');
// 2.2、写入一个字符串
fileWriter.write("test");
fileWriter.write('\n');
// 2.3、写入一个字符数组
char[] chars = "test".toCharArray();
fileWriter.write(chars);
fileWriter.write('\n');
fileWriter.write(chars, 0, 2);
fileWriter.write('\n');
// 2.4、写入一个字符串的一部分
String str = "test";
fileWriter.write(str,0,2);
fileWriter.write('\n');
// 3、关闭管道
fileWriter.close();
}
FileWriter写的注意事项
FileWriter写完数据之后，必须刷新或者关闭，写出去的数据才能生效。
比如：下面的代码只调用了写数据的方法，没有关流的方法。当你打开目标文件时，是看不到任何数据的。
//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");
//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');
而下面的代码，加上了flush()方法之后，数据就会立即到目标文件中去。
//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");
//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');
//3.刷新
fw.flush();
下面的代码，调用了close()方法，数据也会立即到文件中去。因为close()方法在关闭流之前，会将内存中缓存的数据先刷新到文件，再关流。
//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");
//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');
//3.关闭流
fw.close(); //会先刷新，再关流
但是需要注意的是，关闭流之后，就不能在对流进行操作了。否则会出异常
缓冲流
缓冲流有四种，如下图所示：
缓冲流的作用：可以对原始流进行包装，提高原始流读写数据的性能。
缓冲字节流
缓冲流是如何提高读写数据的性能的，原理如下图所示。是因为在缓冲流的底层自己封装了一个长度为8KB（8129byte）的字节数组，但是缓冲流不能单独使用，它需要依赖于原始流。
**读数据时：**它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字节数组中读取一个字节或者多个字节（把消耗屯的货）。
写数据时： 它是先把数据写到缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字节输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。
在创建缓冲字节流对象时，需要封装一个原始流对象进来。构造方法如下：
| 构造方法 | 描述 |
|---|---|
BufferedInputStream(InputStream in) | 创建一个新的 BufferedInputStream 对象，将数据读取到内部缓冲区中，并从缓冲区中读取数据。 |
BufferedInputStream(InputStream in, int bufferSize) | 创建一个新的 BufferedInputStream 对象，指定缓冲区大小，并将数据读取到内部缓冲区中。 |
BufferedOutputStream(OutputStream out) | 创建一个新的 BufferedOutputStream 对象，将数据写入内部缓冲区中，并从缓冲区中写入数据到输出流。 |
BufferedOutputStream(OutputStream out, int bufferSize) | 创建一个新的 BufferedOutputStream 对象，指定缓冲区大小，并将数据写入内部缓冲区中。 |
| 方法 | 描述 |
|---|---|
int read() | 从缓冲输入流中读取一个字节的数据。 |
int read(byte[] b) | 从缓冲输入流中读取字节数组的数据，并将读取的字节数据存储到指定的字节数组中。 |
int read(byte[] b, int off, int len) | 从缓冲输入流中读取字节数组的数据，并将读取的字节数据存储到指定的字节数组的指定位置开始的部分中。 |
void write(int b) | 向缓冲输出流中写入一个字节的数据。 |
void write(byte[] b) | 向缓冲输出流中写入字节数组的数据。 |
void write(byte[] b, int off, int len) | 向缓冲输出流中写入字节数组的部分数据。 |
void flush() | 刷新缓冲输出流，将缓冲区中的数据写入到输出流中。 |
void close() | 关闭缓冲输入流或缓冲输出流。 |
如果我们用缓冲流复制文件，代码写法如下:
public static void main(String[] args) {
try (InputStream is = new FileInputStream("dat17IO/data/data.txt");
// 1、定义一个字节缓冲输入流包装原始的字节输入流
InputStream bis = new BufferedInputStream(is);
OutputStream os = new FileOutputStream("io-app2/src/itheima01_bak.txt");
// 2、定义一个字节缓冲输出流包装原始的字节输出流
OutputStream bos = new BufferedOutputStream(os);) {
byte[] buffer = new byte[1024];
int len;
while ((len = bis.read(buffer)) != -1) {
bos.write(buffer, 0, len);
}
System.out.println("复制完成！！");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
缓冲字符流
字符缓冲流它的原理和字节缓冲流是类似的，它底层也会有一个8KB的数组，但是这里是字符数组。字符缓冲流也不能单独使用，它需要依赖于原始字符流一起使用。
**BufferedReader读数据时：**它先原始字符输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字符数组中读取一个字符或者多个字符（把消耗屯的货）。
创建BufferedReader对象需要用到BufferedReader的构造方法，内部需要封装一个原始的字符输入流，我们可以传入FileReader.
| 构造方法 | 描述 |
|---|---|
BufferedReader(Reader in) | 创建一个新的 BufferedReader 对象，将数据从指定的字符输入流中读取，并将其放入内部缓冲区中。 |
BufferedReader(Reader in, int sz) | 创建一个新的 BufferedReader 对象，指定缓冲区大小，并将数据从指定的字符输入流中读取，并放入内部缓冲区中。 |
而且BufferedReader还要特有的方法，一次可以读取文本文件中的一行
| 方法 | 描述 |
|---|---|
String readLine() | 从缓冲字符输入流中读取一行文本，并返回读取的文本内容。如果达到流的末尾，则返回 null。 |
int read() | 读取单个字符的数据。 |
int read(char[] cbuf) | 将字符数据读入字符数组中。 |
int read(char[] cbuf, int off, int len) | 将字符数据读入指定位置的字符数组中。 |
long skip(long n) | 跳过指定数量的字符。 |
boolean ready() | 判断字符输入流是否准备好被读取。 |
void close() | 关闭字符输入流。 |
public static void main(String[] args) {
try {
BufferedReader bufferedReader = new BufferedReader(new FileReader("day17IO/data/data.txt"));
// 方法一
char[] buffer = new char[3];
int len;
while ((len = bufferedReader.read(buffer)) != -1){
System.out.print(new String(buffer, 0, len));
}
// 方法二
String line; // 记录每次读取的一行数据
while (((line = bufferedReader.readLine())) != null) {
System.out.println(line);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
BufferedWriter写数据时： 它是先把数据写到字符缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字符输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。如下图所示
创建BufferedWriter对象时需要用到BufferedWriter的构造方法，而且内部需要封装一个原始的字符输出流，我们这里可以传递FileWriter。
| 构造方法 | 描述 |
|---|---|
BufferedWriter(Writer out) | 创建一个新的 BufferedWriter 对象，将数据写入指定的字符输出流，并将其放入内部缓冲区中。 |
BufferedWriter(Writer out, int sz) | 创建一个新的 BufferedWriter 对象，指定缓冲区大小，并将数据写入指定的字符输出流中，并放入内部缓冲区中。 |
而且BufferedWriter新增了一个功能，可以用来写一个换行符
| 方法 | 描述 |
|---|---|
void write(String str) | 将指定的字符串写入字符输出流。 |
void write(char[] cbuf) | 将字符数组写入字符输出流。 |
void write(char[] cbuf, int off, int len) | 将字符数组的一部分写入字符输出流。 |
void newLine() | 写入一个行分隔符到字符输出流。 |
void flush() | 刷新字符输出流，将缓冲区中的数据写入到输出流中。 |
void close() | 关闭字符输出流。 |
public static void main(String[] args) {
try {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("day17IO/data/data.txt",true));
bufferedWriter.write("您好，中国！");
bufferedWriter.newLine();
bufferedWriter.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
缓冲流性能分析
我们说缓冲流内部多了一个数组，可以提高原始流的读写性能。讲到这一定有同学有这么一个疑问，它和我们使用原始流，自己加一个8BK数组不是一样的吗？ 缓冲流就一定能提高性能吗？先告诉同学们答案，缓冲流不一定能提高性能。
下面我们用一个比较大文件（889MB）复制，做性能测试，分别使用下面四种方式来完成文件复制，并记录文件复制的时间。
① 使用低级流一个字节一个字节的复制
② 使用低级流按照字节数组的形式复制
③ 使用缓冲流一个字节一个字节的复制
④ 使用缓冲流按照字节数组的形式复制
低级流一个字节复制: 慢得简直让人无法忍受
低级流按照字节数组复制(数组长度1024): 12.117s
缓冲流一个字节复制: 11.058s
缓冲流按照字节数组复制(数组长度1024): 2.163s
【注意：这里的测试只能做一个参考，和电脑性能也有直接关系】
经过上面的测试，我们可以得出一个结论：默认情况下，采用一次复制1024个字节，缓冲流完胜。
但是，缓冲流就一定性能高吗？我们采用一次复制8192个字节试试
低级流按照字节数组复制(数组长度8192): 2.535s
缓冲流按照字节数组复制(数组长度8192): 2.088s
经过上面的测试，我们可以得出一个结论：**一次读取8192个字节时，低级流和缓冲流性能相当。**相差的那几毫秒可以忽略不计。
继续把数组变大，看一看缓冲流就一定性能高吗？现在采用一次读取1024*32个字节数据试试
低级流按照字节数组复制(数组长度8192): 1.128s
缓冲流按照字节数组复制(数组长度8192): 1.133s
经过上面的测试，我们可以得出一个结论：**数组越大性能越高，低级流和缓冲流性能相当。**相差的那几秒可以忽略不计。
继续把数组变大，看一看缓冲流就一定性能高吗？现在采用一次读取1024*6个字节数据试试
低级流按照字节数组复制(数组长度8192): 1.039s
缓冲流按照字节数组复制(数组长度8192): 1.151s
此时你会发现，当数组大到一定程度，性能已经提高了多少了，甚至缓冲流的性能还没有低级流高。
最终总结一下：**缓冲流的性能不一定比低级流高，其实低级流自己加一个数组，性能其实是不差。**只不过缓冲流帮你加了一个相对而言大小比较合理的数组 。
转换流
FileReader默认只能读取UTF-8编码格式的文件。如果使用FileReader读取GBK格式的文件，可能存在乱码，因为FileReader它遇到汉字默认是按照3个字节来读取的，而GBK格式的文件一个汉字是占2个字节，这样就会导致乱码。
Java给我们提供了另外两种流InputStreamReader，OutputStreamWriter，这两个流我们把它叫做转换流。它们可以将字节流转换为字符流，并且可以指定编码方案。
InputStreamReader类
InputStreamReader类，你看这个类名就比较有意思，前面是InputStream表示字节输入流，后面是Reader表示字符输入流，合在一起意思就是表示可以把InputStream转换为Reader，最终InputStreamReader其实也是Reader的子类，所以也算是字符输入流。
InputStreamReader也是不能单独使用的，它内部需要封装一个InputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。
| 构造方法 | 描述 |
|---|---|
InputStreamReader(InputStream in) | 创建一个新的 InputStreamReader 对象，使用默认字符集将字节输入流转换为字符输入流。 |
InputStreamReader(InputStream in, Charset cs) | 创建一个新的 InputStreamReader 对象，使用指定的字符集将字节输入流转换为字符输入流。 |
InputStreamReader(InputStream in, String charsetName) | 创建一个新的 InputStreamReader 对象，使用指定字符集名称将字节输入流转换为字符输入流。 |
InputStreamReader(InputStream in, CharsetDecoder dec) | 创建一个新的 InputStreamReader 对象，使用指定的字符集解码器将字节输入流转换为字符输入流。 |
InputStreamReader(InputStream in, CharsetDecoder dec, int bufferSize) | 创建一个新的 InputStreamReader 对象，使用指定的字符集解码器将字节输入流转换为字符输入流，并指定缓冲区大小。 |
| 方法 | 描述 |
|---|---|
int read() | 读取单个字符的数据。 |
int read(char[] cbuf) | 将字符数据读入字符数组中。 |
int read(char[] cbuf, int off, int len) | 将字符数据读入指定位置的字符数组中。 |
boolean ready() | 判断字符输入流是否准备好被读取。 |
void close() | 关闭字符输入流。 |
需求：我们可以先准备一个GBK格式的文件，然后使用下面的代码进行读取，看是是否有乱码。
data.txt
你好，中国！
hello world!
public static void main(String[] args) {
try (
// 1、得到文件的原始字节流（GBK的字节流形式）
FileInputStream inputStream = new FileInputStream("day17IO/data/data.txt");
// 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
Reader reader = new InputStreamReader(inputStream, "GBK");
// 3、把字符输入流包装成缓冲字符输入流
BufferedReader bufferedReader = new BufferedReader(reader)) {
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
OutputStreamWriter类
OutputStreamWriter类，你看这个类名也比较有意思，前面是OutputStream表示字节输出流，后面是Writer表示字符输出流，合在一起意思就是表示可以把OutputStream转换为Writer，最终OutputStreamWriter其实也是Writer的子类，所以也算是字符输出流。
OutputStreamReader也是不能单独使用的，它内部需要封装一个OutputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。
| 构造方法 | 描述 |
|---|---|
OutputStreamWriter(OutputStream out) | 创建一个新的 OutputStreamWriter 对象，使用默认字符集将字符输出流转换为字节输出流。 |
OutputStreamWriter(OutputStream out, Charset cs) | 创建一个新的 OutputStreamWriter 对象，使用指定的字符集将字符输出流转换为字节输出流。 |
OutputStreamWriter(OutputStream out, String charsetName) | 创建一个新的 OutputStreamWriter 对象，使用指定字符集名称将字符输出流转换为字节输出流。 |
OutputStreamWriter(OutputStream out, CharsetEncoder enc) | 创建一个新的 OutputStreamWriter 对象，使用指定的字符集编码器将字符输出流转换为字节输出流。 |
OutputStreamWriter(OutputStream out, CharsetEncoder enc, int bufferSize) | 创建一个新的 OutputStreamWriter 对象，使用指定的字符集编码器将字符输出流转换为字节输出流，并指定缓冲区大小。 |
| 方法 | 描述 |
|---|---|
void write(int c) | 将单个字符写入字符输出流。 |
void write(char[] cbuf) | 将字符数组写入字符输出流。 |
void write(char[] cbuf, int off, int len) | 将字符数组的一部分写入字符输出流。 |
void write(String str) | 将字符串写入字符输出流。 |
void write(String str, int off, int len) | 将字符串的一部分写入字符输出流。 |
void flush() | 刷新字符输出流。 |
void close() | 关闭字符输出流。 |
需求：我们可以先准备一个GBK格式的文件，然后使用下面的代码进行读取，看是是否有乱码。
public static void main(String[] args) {
try (
// 1、创建一个文件字节输出流
OutputStream outputStream = new FileOutputStream("day17IO/data/data.txt",true);
// 2、把原始的字节输出流，按照指定的字符集编码转换成字符输出转换流。
Writer writer = new OutputStreamWriter(outputStream,"GBK");
// 3、把字符输出流包装成缓冲字符输出流
BufferedWriter buffWriter = new BufferedWriter(writer)){
buffWriter.newLine();
buffWriter.write("你好，世界！");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
打印流
打印流可以实现更加方便，更加高效的写数据的方式。
打印流基本使用
打印流，这里所说的打印其实就是写数据的意思，它和普通的write方法写数据还不太一样，一般会使用打印流特有的方法叫print(数据)或者println(数据)，它打印啥就输出啥。
打印流有两个，一个是字节打印流PrintStream，一个是字符打印流PrintWriter，如下图所示:
| 打印流类 | 构造方法 | 方法 |
|---|---|---|
| PrintStream | PrintStream(OutputStream out) | 将数据打印到指定的输出流 |
| PrintStream(File file) | 将数据打印到指定的文件 | |
| PrintStream(String fileName) | 将数据打印到指定文件名的文件 | |
| PrintWriter | PrintWriter(OutputStream out) | 将数据打印到指定的输出流 |
| PrintWriter(Writer out) | 将数据打印到指定的字符输出流 | |
| PrintWriter(File file) | 将数据打印到指定的文件 | |
| PrintWriter(String fileName) | 将数据打印到指定文件名的文件 |
| 方法 | 描述 |
|---|---|
| void print(boolean b) | 打印布尔值 |
| void print(char c) | 打印字符 |
| void print(double d) | 打印双精度浮点数 |
| void print(float f) | 打印单精度浮点数 |
| void print(int i) | 打印整数 |
| void print(long l) | 打印长整数 |
| void print(Object obj) | 打印对象 |
| void print(String s) | 打印字符串 |
| void println() | 打印换行符 |
| void println(boolean x) | 打印布尔值并换行 |
| void println(char x) | 打印字符并换行 |
| void println(double x) | 打印双精度浮点数并换行 |
| void println(float x) | 打印单精度浮点数并换行 |
| void println(int x) | 打印整数并换行 |
| void println(long x) | 打印长整数并换行 |
| void println(Object x) | 打印对象并换行 |
| void println(String x) | 打印字符串并换行 |
| void println(char[] x) | 打印字符数组并换行 |
PrintStream和PrintWriter的用法是一样的
public static void main(String[] args) {
try (
// 1、创建一个打印流管道
// PrintStream ps = new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK"));
// PrintStream ps = new PrintStream("io-app2/src/itheima08.txt");
PrintWriter ps = new PrintWriter(new FileOutputStream("io-app2/src/itheima08.txt", true))){
ps.print(97); //文件中显示的就是:97
ps.print('a'); //文件中显示的就是:a
ps.println("我爱你中国abc"); //文件中显示的就是:我爱你中国abc
ps.println(true);//文件中显示的就是:true
ps.println(99.5);//文件中显示的就是99.5
ps.write(97); //文件中显示a，发现和前面println方法的区别了吗？
} catch (Exception e) {
e.printStackTrace();
}
}
重定向输出语句
System里面有一个静态变量叫out，out的数据类型就是PrintStream，它就是一个打印流，而且这个打印流的默认输出目的地是控制台，所以我们调用System.out.pirnln()就可以往控制台打印输出任意类型的数据，而且打印啥就输出啥。
| 构造方法 | 描述 |
|---|---|
PrintStream(File file) | 创建一个新的 PrintStream 对象，将数据打印到指定的文件。 |
PrintStream(File file, String csn) | 创建一个新的 PrintStream 对象，将数据打印到指定的文件，并使用指定的字符集。 |
PrintStream(OutputStream out) | 创建一个新的 PrintStream 对象，将数据打印到指定的输出流。 |
PrintStream(OutputStream out, boolean autoFlush) | 创建一个新的 PrintStream 对象，将数据打印到指定的输出流，并设置是否自动刷新缓冲区。 |
PrintStream(OutputStream out, boolean autoFlush, Charset charset) | 创建一个新的 PrintStream 对象，将数据打印到指定的输出流，并设置是否自动刷新缓冲区以及使用的字符集。 |
而且System还提供了一个方法，可以修改底层的打印流，这样我们就可以重定向打印语句的输出目的地了。
public static void main(String[] args) {
System.out.println("老骥伏枥");
System.out.println("志在千里");
try ( PrintStream ps = new PrintStream("io-app2/src/itheima09.txt"); ){
// 把系统默认的打印流对象改成自己设置的打印流
System.setOut(ps);
System.out.println("烈士暮年");
System.out.println("壮心不已");
} catch (Exception e) {
e.printStackTrace();
}
}
数据流
我们想把数据和数据的类型一并写到文件中去，读取的时候也将数据和数据类型一并读出来。这就可以用到数据流，有两个DataInputStream和DataOutputStream.
DataOutputStream类
DataOutputStream类，它也是一种包装流，创建DataOutputStream对象时，底层需要依赖于一个原始的OutputStream流对象。然后调用它的wirteXxx方法，写的是特定类型的数据。
| 构造方法 | 描述 |
|---|---|
DataOutputStream(OutputStream out) | 创建一个新的 DataOutputStream 对象，用于将数据以二进制形式写入指定的输出流。 |
DataOutputStream(OutputStream out, boolean littleEndian) | 创建一个新的 DataOutputStream 对象，指定是否使用小端字节序（little-endian）写入数据到输出流。 |
| 方法 | 描述 |
|---|---|
void write(int b) | 将指定的字节（低八位）写入输出流。 |
void write(byte[] b) | 将字节数组的数据写入输出流。 |
void writeBoolean(boolean v) | 将布尔值以单字节形式写入输出流。 |
void writeByte(int v) | 将一个字节数据写入输出流。 |
void writeShort(int v) | 将一个短整型数据以两个字节形式写入输出流。 |
void writeChar(int v) | 将一个字符数据以两个字节形式写入输出流。 |
void writeInt(int v) | 将一个整型数据以四个字节形式写入输出流。 |
void writeLong(long v) | 将一个长整型数据以八个字节形式写入输出流。 |
void writeFloat(float v) | 将一个浮点型数据以四个字节形式写入输出流。 |
void writeDouble(double v) | 将一个双精度浮点型数据以八个字节形式写入输出流。 |
void writeBytes(String s) | 将字符串中的每个字符的低八位字节写入输出流。 |
void writeChars(String s) | 将字符串中的每个字符以两个字节形式写入输出流。 |
void writeUTF(String s) | 将字符串以修订的 UTF-8 编码写入输出流。 |
void flush() | 刷新输出流，将缓冲区中的数据写入到输出设备中。 |
void close() | 关闭输出流。 |
public static void main(String[] args) {
try (
// 1、创建一个数据输出流包装低级的字节输出流
DataOutputStream dos = new DataOutputStream(new FileOutputStream("day17IO/data/data.txt",true))){
dos.writeInt(97);
dos.writeDouble(99.5);
dos.writeBoolean(true);
dos.writeUTF("hello world！");
} catch (Exception e) {
e.printStackTrace();
}
}
DataInputStream类
DataIntputStream类，它也是一种包装流，创建DataInputStream对象时，底层需要依赖于一个原始的InputStream流对象。然后调用它的readXxx()方法就可以读取特定类型的数据。
| 构造方法 | 描述 |
|---|---|
DataInputStream(InputStream in) | 创建一个新的 DataInputStream 对象，用于从指定的输入流读取数据并解析为各种基本数据类型。 |
DataInputStream(InputStream in, boolean littleEndian) | 创建一个新的 DataInputStream 对象，指定是否使用小端字节序（little-endian）读取数据从输入流中解析。 |
| 方法 | 描述 |
|---|---|
int read() | 读取一个字节的数据。 |
int read(byte[] b) | 从输入流中读取字节数组的数据，并将读取的字节数据存储到指定的字节数组中。 |
boolean readBoolean() | 读取一个布尔值。 |
byte readByte() | 读取一个字节数据。 |
short readShort() | 读取一个短整型数据。 |
char readChar() | 读取一个字符数据。 |
int readInt() | 读取一个整型数据。 |
long readLong() | 读取一个长整型数据。 |
float readFloat() | 读取一个浮点型数据。 |
double readDouble() | 读取一个双精度浮点型数据。 |
String readUTF() | 读取修订的 UTF-8 编码字符串。 |
void close() | 关闭输入流。 |
public static void main(String[] args) {
try (DataInputStream dis =new DataInputStream(new FileInputStream("day17IO/data/data.txt"))){
int i = dis.readInt();
System.out.println(i);
double d = dis.readDouble();
System.out.println(d);
boolean b = dis.readBoolean();
System.out.println(b);
String rs = dis.readUTF();
System.out.println(rs);
} catch (Exception e) {
e.printStackTrace();
}
}
序列化流
序列化流是干什么用的呢？ 我们知道字节流是以字节为单位来读写数据、字符流是按照字符为单位来读写数据、而对象流是以对象为单位来读写数据。也就是把对象当做一个整体，可以写一个对象到文件，也可以从文件中把对象读取出来。
序列化：意思就是把对象写到文件或者网络中去。（简单记：写对象）
反序列化：意思就是把对象从文件或者网络中读取出来。（简单记：读对象）
ObjectOutputStream类
ObjectOutputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输出流使用。
| 构造方法 | 描述 |
|---|---|
ObjectOutputStream(OutputStream out) | 创建一个新的 ObjectOutputStream 对象，用于将对象以序列化形式写入指定的输出流中。 |
ObjectOutputStream(OutputStream out, boolean append) | 创建一个新的 ObjectOutputStream 对象，指定是否以追加模式写入对象到指定的输出流中。 |
ObjectOutputStream(OutputStream out, int protocolVersion) | 创建一个新的 ObjectOutputStream 对象，指定协议版本，并将对象以序列化形式写入指定的输出流中。 |
| 方法 | 描述 |
|---|---|
void writeObject(Object obj) | 将指定的对象以序列化形式写入输出流中。 |
void write(byte[] buf, int off, int len) | 将指定字节数组的一部分写入输出流中。 |
void flush() | 刷新输出流，将缓冲区中的数据写入到输出设备中。 |
void close() | 关闭输出流。 |
代码如下：将一个User对象写到文件中去
- 第一步：先准备一个User类，必须让其实现Serializable接口。
// 注意：对象如果需要序列化，必须实现序列化接口。
public class User implements Serializable {
private String loginName;
private String userName;
private int age;
// transient 这个成员变量将不参与序列化。
private transient String passWord;
public User() {
}
public User(String loginName, String userName, int age, String passWord) {
this.loginName = loginName;
this.userName = userName;
this.age = age;
this.passWord = passWord;
}
@Override
public String toString() {
return "User{" +
"loginName='" + loginName + '\'' +
", userName='" + userName + '\'' +
", age=" + age +
", passWord='" + passWord + '\'' +
'}';
}
}
- 第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。
public class Test1ObjectOutputStream {
public static void main(String[] args) {
try (
// 2、创建一个对象字节输出流包装原始的字节 输出流。
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day17IO/data/data.txt"));
){
// 1、创建一个Java对象。
User u = new User("admin", "张三", 32, "123456");
// 3、序列化对象到文件中去
oos.writeObject(u);
System.out.println("序列化对象成功！！");
} catch (Exception e) {
e.printStackTrace();
}
}
}
注意：写到文件中的对象，是不能用记事本打开看的。因为对象本身就不是文本数据，打开是乱码
怎样才能读懂文件中的对象是什么呢？这里必须用反序列化，自己写代码读。
ObjectInputStream类
ObjectInputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输入流使用。
| 构造方法 | 描述 |
|---|---|
ObjectInputStream(InputStream in) | 创建一个新的 ObjectInputStream 对象，用于从指定的输入流中读取序列化对象。 |
ObjectInputStream(InputStream in, int bufferSize) | 创建一个新的 ObjectInputStream 对象，指定输入缓冲区大小，并从指定的输入流中读取序列化对象。 |
ObjectInputStream(InputStream in, ClassLoader loader) | 创建一个新的 ObjectInputStream 对象，指定类加载器，并从指定的输入流中读取序列化对象。 |
| 方法 | 描述 |
|---|---|
Object readObject() | 从输入流中读取并反序列化一个对象。 |
int read() | 读取一个字节的数据。 |
int read(byte[] buf) | 从输入流中读取字节数组的数据。 |
int read(byte[] buf, int off, int len) | 从输入流中读取字节数组的部分数据。 |
void close() | 关闭输入流。 |
接着前面的案例，文件中已经有一个Student对象，现在要使用ObjectInputStream读取出来。称之为反序列化。
public class Test2ObjectInputStream {
public static void main(String[] args) {
try (
// 1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day17IO/data/data.txt"));
){
User u = (User) ois.readObject();
System.out.println(u);
} catch (Exception e) {
e.printStackTrace();
}
}
}
IO框架
为了简化对IO操作，由apache开源基金组织提供了一组有关IO流小框架，可以提高IO流的开发效率。
这个框架的名字叫commons-io：其本质是别人写好的一些字节码文件（class文件），打包成了一个jar包。我们只需要把jar包引入到我们的项目中，就可以直接用了。
在写代码之前，先需要引入jar包，具体步骤如下
1.在模块的目录下，新建一个lib文件夹
2.把jar包复制粘贴到lib文件夹下
3.选择lib下的jar包，右键点击Add As Library，然后就可以用了。
public class CommonsIOTest1 {
public static void main(String[] args) throws Exception {
//1.复制文件
FileUtils.copyFile(new File("day17IO/data/data.txt"), new File("day17IO/data/data_bak.txt"));
//2.复制文件夹
FileUtils.copyDirectory(new File("D:\\resource\\test"), new File("D:\\resource\\test"));
//3.删除文件夹
FileUtils.deleteDirectory(new File("D:\\resource\\test"));
// Java提供的原生的一行代码搞定很多事情
Files.copy(Path.of("day17IO/data/data.txt"), Path.of("day17IO/data/data_bak.txt"));
System.out.println(Files.readString(Path.of("day17IO/data/data.txt"));
}
}
4946
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
