1、IO流概述
1.1 什么是IO流
Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。
1.2 Java IO原理
Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行，可以看做是一种数据的流动。
I/O流中的I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。
1.3 IO的分类
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
按数据的流向不同分为：输入流和输出流。
- 输入流 ：把数据从其他设备上读取到内存中的流。 以InputStream、Reader结尾
- 输出流 ：把数据从内存 中写出到其他设备上的流。以OutputStream、Writer结尾
按操作数据单位的不同分为：字节流（8bit）和字符流（16bit）。
- 字节流 ：以字节为单位，读写数据的流。以InputStream、OutputStream结尾
- 字符流 ：以字符为单位，读写数据的流。以Reader、Writer结尾
根据IO流的角色不同分为：节点流和处理流。
- 节点流：直接从数据源或目的地读写数据
- 处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。
小结：图解
1.4 流的API
Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。
| （抽象基类） | 输入流 | 输出流 |
| 字节流 | InputStream | OutputStream |
| 字符流 | Reader | Writer |
由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
常用的节点流：
文件流： FileInputStream、FileOutputStrean、FileReader、FileWriter
字节/字符数组流： ByteArrayInputStream、ByteArrayOutputStream、CharArrayReader、CharArrayWriter
对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。
常用处理流：
缓冲流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
作用：增加缓冲功能，避免频繁读写硬盘，进而提升读写效率。
转换流：InputStreamReader、OutputStreamReader
作用：实现字节流和字符流之间的转换。
对象流：ObjectInputStream、ObjectOutputStream
作用：提供直接读写Java对象功能
2、字符流 FileReader\FileWriter
2.1 Reader与Writer
Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。不能操作图片，视频等非文本文件。
常见的文本文件有如下的格式：.txt、.java、.c、.cpp、.py等
注意：.doc、.xls、.ppt这些都不是文本文件。
2.1.1 字符输入流：Reader
java.io.Reader抽象类是表示用于读取字符流的所有类的父类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
- public int read()： 从输入流读取一个字符。 虽然读取了一个字符，但是会自动提升为int类型。返回该字符的Unicode编码值。如果已经到达流末尾了，则返回-1。
- public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。每次最多读取cbuf.length个字符。返回实际读取的字符个数。如果已经到达流末尾，没有数据可读，则返回-1。
- public int read(char[] cbuf,int off,int len)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中，从cbuf[off]开始的位置存储。每次最多读取len个字符。返回实际读取的字符个数。如果已经到达流末尾，没有数据可读，则返回-1。
- public void close() ：关闭此流并释放与此流相关联的任何系统资源。
注意：当完成流的操作时，必须调用close()方法，释放系统资源，否则会造成内存泄漏。
2.1.2 字符输出流：Writer
java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
- public void write(int c) ：写出单个字符。
- public void write(char[] cbuf)：写出字符数组。
- public void write(char[] cbuf, int off, int len)：写出字符数组的某一部分。off：数组的开始索引；len：写出的字符个数。
- public void write(String str)：写出字符串。
- public void write(String str, int off, int len) ：写出字符串的某一部分。off：字符串的开始索引；len：写出的字符个数。
- public void flush()：刷新该流的缓冲。
- public void close() ：关闭此流。
注意：当完成流的操作时，必须调用close()方法，释放系统资源，否则会造成内存泄漏。
2.2 FileReader 与 FileWriter
2.2.1 FileReader
java.io.FileReader类用于读取字符文件，构造时使用系统默认的字符编码和默认字节缓冲区。
- FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
- FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。
举例：读取hello.txt文件中的字符数据，并显示在控制台上
package com.suyv.test01;
import org.junit.Test;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-19 20:13
*@Description: 读取hello.txt文件中的字符数据，并显示在控制台上
*/
public class FileReader01 {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
//2. 创建FileReader流对象，将File类的对象作为参数传递到FileReader的构造器中
//3. 通过相关流的方法，读取文件中的数据
//4. 关闭相关的流资源，避免出现内存泄漏
@Test
public void Test01() throws IOException {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
File file = new File("file\\hello.txt");
//2. 创建FileReader流对象，将File类的对象作为参数传递到FileReader的构造器中
FileReader fr = new FileReader(file);
//3. 通过相关流的方法，读取文件中的数据
// int data = fr.read(); //每调用一次读取一个字符
// while (data != -1) {
// System.out.print((char) data);
// data = fr.read();
// }
int data;
while ((data = fr.read()) != -1) {
System.out.print((char) data);
}
//4. 关闭相关的流资源，避免出现内存泄漏
fr.close();
}
/*
* 需求：读取hello.txt中的内容，显示在控制台上。
* 使用try-catch-finally的方式处理异常。确保流一定可以关闭，避免内存泄漏
* */
@Test
public void Test02() {
FileReader fr = null;
try {
//1.创建File类的对象，对应着hello.txt文件
File file = new File("file\\hello.txt");
//2.创建输入型的字符流，用于读取数据
fr = new FileReader(file);
//3.读取数据，并显示在控制台上
int data;
while ((data = fr.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4. 流资源的关闭操作（必须要关闭，否则会内存泄漏）
try {
if (fr != null)
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void test3() throws IOException {
//1.创建File类的对象，对应着hello.txt文件
File file = new File("file\\hello.txt");
//2.创建输入型的字符流，用于读取数据
FileReader fr = new FileReader(file);
//3.读取数据，并显示在控制台上
char[] cbuffer = new char[5];
int len;
while ((len = fr.read(cbuffer)) != -1) {
//遍历数组
for (int i = 0; i < len; i++) {
System.out.print(cbuffer[i]);
}
}
//4. 流资源的关闭操作（必须要关闭，否则会内存泄漏）
fr.close();
}
}2.2.2 FileWriter
java.io.FileWriter类用于写出字符到文件，构造时使用系统默认的字符编码和默认字节缓冲区。
- FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
- FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。
- FileWriter(File file,boolean append)： 创建一个新的 FileWriter，指明是否在现有文件末尾追加内容。
举例：将内存中的数据写出到指定的文件中
package com.suyv.test01;
import org.junit.Test;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Author: 憨憨浩浩
* @CreateTime: 2023-12-20 13:54
* @Description: FileWriter的使用--需求：将内存中的数据写出到指定的文件中
*/
public class FileWriter01 {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
//2. 创建FileWriter流对象，将File类的对象作为参数传递到FileWriter的构造器中
//3. 通过相关流的方法，读取文件中的数据
//4. 关闭相关的流资源，避免出现内存泄漏
@Test
public void Test01() throws IOException {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
File file = new File("file\\info.txt");
//2. 创建FileWriter流对象，将File类的对象作为参数传递到FileWriter的构造器中
FileWriter fw = new FileWriter(file);
//3. 通过相关流的方法，读取文件中的数据
fw.write("HelloWorld\n");
fw.write("中国");
System.out.println("写入成功");
//4. 关闭相关的流资源，避免出现内存泄漏
fw.close();
}
}2.2.3 复制文件
package com.suyv.test01;
import org.junit.Test;
import java.io.*;
/**
* @Author: 憨憨浩浩
* @CreateTime: 2023-12-20 14:23
* @Description: 复制一份hello.txt文件，命名为hello_copy.txt
*/
public class FileReaderWriter {
@Test
public void Test01() throws IOException {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
File file1 = new File("file\\hello.txt");
File file2 = new File("file\\hello_copy.txt");
//2. 创建FileWriter流和FileReader流对象，将File类的对象作为参数传递到FileWriter的构造器中
FileReader fr = new FileReader(file1);
FileWriter fw = new FileWriter(file2);
//3. 通过相关流的方法，读取文件中的数据
int len; // 记录每次读入到cbuffer中的字符的个数
char[] cbuffer = new char[5];
while ((len = fr.read(cbuffer)) != -1){
fw.write(cbuffer,0,len);
}
//4. 关闭相关的流资源，避免出现内存泄漏
fw.close();
fr.close();
}
}2.2.4 小结
① 因为出现流资源的调用，为了避免内存泄漏，需要使用try-catch-finally处理异常
② 对于输入流来说，File类的对象必须在物理磁盘上存在，否则执行就会报FileNotFoundException。如果传入的是一个目录，则会报IOException异常。
对于输出流来说，File类的对象是可以不存在的。
如果File类的对象不存在，则可以在输出的过程中，自动创建File类的对象
如果File类的对象存在，
如果调用FileWriter(File file)或FileWriter(File file,false)，输出时会新建File文件覆盖已有的文件
如果调用FileWriter(File file,true)构造器，则在现有的文件末尾追加写出内容。
2.3 关于flush（刷新）
因为内置缓冲区的原因，如果FileWriter不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush() 方法了。
- flush() ：刷新缓冲区，流对象可以继续使用。
- close()：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
注意：即便是flush()方法写出了数据，操作的最后还是要调用close方法，释放系统资源。
举例：
package com.suyv.test01;
import org.junit.Test;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Author: 憨憨浩浩
* @CreateTime: 2023-12-20 14:36
* @Description: flush的使用
*/
public class FileReaderFlush {
@Test
public void Test01() throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("file\\fw.txt");
// 写出数据，通过flush
fw.write('刷'); // 写出第1个字符
fw.flush();
fw.write('新'); // 继续写出第2个字符，写出成功
fw.flush();
// 写出数据，通过close
fw.write('关'); // 写出第1个字符
fw.close();
fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
fw.close();
}
}3、字节流 FileInputStream\FileOutputStream
如果我们读取或写出的数据是非文本文件，则Reader、Writer就无能为力了，必须使用字节流。
3.1 InputStream和OutputStream
3.1.1 字节输入流：InputStream
java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
- public int read()： 从输入流读取一个字节。返回读取的字节值。虽然读取了一个字节，但是会自动提升为int类型。如果已经到达流末尾，没有数据可读，则返回-1。
- public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。每次最多读取b.length个字节。返回实际读取的字节个数。如果已经到达流末尾，没有数据可读，则返回-1。
- public int read(byte[] b,int off,int len)：从输入流中读取一些字节数，并将它们存储到字节数组 b中，从b[off]开始存储，每次最多读取len个字节 。返回实际读取的字节个数。如果已经到达流末尾，没有数据可读，则返回-1。
- public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
说明：close()方法，当完成流的操作时，必须调用此方法，释放系统资源。
3.1.2 字节输出流：OutputStream
java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
- public void write(int b) ：将指定的字节输出流。虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
- public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
- public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
- public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
- public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
说明：close()方法，当完成流的操作时，必须调用此方法，释放系统资源。
3.2 FileInputStream 与 FileOutputStream
3.2.1 FileInputStream
java.io.FileInputStream类是文件输入流，从文件中读取字节。
- FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
- FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
读取操作：
package com.suyv.test02;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* @Author: 憨憨浩浩
* @CreateTime: 2023-12-20 15:51
* @Description: FileInputStream--字节输入流的使用
*/
public class FileInputStream01 {
// 单个接收--无汉字
@Test
public void Test01() throws IOException {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
File file = new File("file\\hello.txt");
//2. 创建FileInputStream流对象
FileInputStream fis = new FileInputStream(file);
//3. 通过相关流的方法，读取文件中的数据
int i;
while ((i = fis.read()) != -1){
System.out.print((char) i); // helloworld111
}
//4. 关闭相关的流资源，避免出现内存泄漏
fis.close();
}
// 单个接收--有汉字utf8
@Test
public void Test02() throws IOException {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
File file = new File("file\\hello1.txt");
//2. 创建FileInputStream流对象
FileInputStream fis = new FileInputStream(file);
//3. 通过相关流的方法，读取文件中的数据
int i;
while ((i = fis.read()) != -1){
// 出现乱码，汉字在gbk中占2个字节，在utf8中占三个字节
System.out.print((char) i); // helloworld111ä¸å½
}
//4. 关闭相关的流资源，避免出现内存泄漏
fis.close();
}
// 使用byte数组接收
@Test
public void Test03() throws IOException {
// 1. 2. 创建fileInputStream对象
FileInputStream fis = new FileInputStream("file\\hello.txt");
// 3. 读取数据
byte[] buffer = new byte[5];
int len;
while ((len = fis.read(buffer)) != -1){
String str = new String(buffer,0,len);
System.out.print(str + "\t"); // hello world 111
// 错误写法
// String str = new String(buffer);
// System.out.print(str + "\t"); // hello world 111ld
}
// 4. 关闭资源
fis.close();
}
// skip(long n) 跳过几个字节
@Test
public void Test04() throws IOException {
// 1. 2. 创建fileInputStream对象
FileInputStream fis = new FileInputStream("file\\hello.txt");
// 3. 读取数据
fis.skip(4);
System.out.println((char) fis.read()); // o
// 4. 关闭资源
fis.close();
}
}3.2.2 FileOutputStream
java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。
- public FileOutputStream(File file)：创建文件输出流，写出由指定的 File对象表示的文件。
- public FileOutputStream(String name)： 创建文件输出流，指定的名称为写出文件。
- public FileOutputStream(File file, boolean append)： 创建文件输出流，指明是否在现有文件末尾追加内容。
举例：
package com.suyv.test02;
import org.junit.Test;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
/**
* @Author: 憨憨浩浩
* @CreateTime: 2023-12-20 16:14
* @Description: FileOutputStream
*/
public class FileOutputStream01 {
@Test
public void Test01() throws IOException {
// 1. 2. 创建FileOutputStream流对象
FileOutputStream fos = new FileOutputStream("file\\fos.txt");
// 3. 执行操作
fos.write(97);
fos.write(98);
fos.write(99);
System.out.println("写入成功");
/*当前fos.txt内容为：abc*/
// 4. 关闭资源
fos.close();
}
@Test
public void Test02() throws IOException {
// 1. 2. 创建FileOutputStream流对象
// 默认为不追加
FileOutputStream fos = new FileOutputStream("file\\fos.txt");
// 3. 执行操作
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
fos.write(b,2,2);
/*当前fos.txt内容为：cd*/
// 4. 关闭资源
fos.close();
}
@Test
public void Test03() throws IOException {
// 1. 2. 创建FileOutputStream流对象
// 添加第二个参数为true时，为文件追加内容
FileOutputStream fos = new FileOutputStream("file\\fos.txt",true);
// 3. 执行操作
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
fos.write(b);
/*当前fos.txt内容为：cdabcde*/
// 4. 关闭资源
fos.close();
}
// 接收控制台输入的内容
@Test
public void Test04() throws IOException {
Scanner scan = new Scanner(System.in);
// 创建流对象
FileOutputStream fos = new FileOutputStream("file\\content.txt");
// 操作流
String str = scan.nextLine();
fos.write(str.getBytes());
/*文件内容为：中国*/
// 关闭资源
fos.close();
}
// 接收控制台输入的内容
@Test
public void Test05() throws IOException {
Scanner scan = new Scanner(System.in);
// 创建流对象
FileOutputStream fos = new FileOutputStream("file\\content.txt");
while (true) {
// 操作流
String str = scan.nextLine();
// 循环退出条件
if (str.equals("-1")){
break;
}
fos.write(str.getBytes());
fos.write('\n');
}
// 关闭资源
fos.close();
}
}3.3 练习
3.3.1 复制图片
package com.suyv.test02;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @Author: 憨憨浩浩
* @CreateTime: 2023-12-20 14:45
* @Description: 复制图片
*/
public class FileInputOutputStream {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
//2. 创建FileReader流对象，将File类的对象作为参数传递到FileReader的构造器中
//3. 通过相关流的方法，读取文件中的数据
//4. 关闭相关的流资源，避免出现内存泄漏
// 复制一份03.png文件，命名为03_copy.png
@Test
public void Test01() throws IOException {
//1. 创建File类的对象，对应着物理磁盘上的某个文件
File file1 = new File("file\\03.png");
File file2 = new File("file\\03_copy.png");
//2. 创建FileInputStream和FileOutputStream流对象
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
//3. 通过相关流的方法，读取文件中的数据
byte[] buffer = new byte[1024]; //1kb
int len;//记录每次读入到buffer中字节的个数
while ((len = fis.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
System.out.println("复制成功");
//4. 关闭相关的流资源，避免出现内存泄漏
fos.close();
fis.close();
}
}3.3.2 实现图片加密操作
package com.suyv.test02;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @Author: 憨憨浩浩
* @CreateTime: 2023-12-20 16:50
* @Description: 图片的加密与加密
*/
public class FileInputOutputStream02 {
// 图片的加密操作
@Test
public void Test01() throws IOException {
//1. 创建File类的对象
File file1 = new File("file\\girl.jpeg");
File file2 = new File("file\\girl_secret.jpeg");
//2. 创建FileInputStream流对象和FileOutputStream流对象
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
//3. 通过相关流的方法，读取文件中的数据
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1){
for (int i = 0; i < len; i++) {
buffer[i] = (byte) (buffer[i] ^ 5);
}
fos.write(buffer,0, len);
}
System.out.println("加密成功");
//4. 关闭相关的流资源，避免出现内存泄漏
fos.close();
fis.close();
}
// 图片的解密操作
@Test
public void Test02() throws IOException {
//1. 创建File类的对象
File file1 = new File("file\\girl_secret.jpeg");
File file2 = new File("file\\girl_unsecret.jpeg");
//2. 创建FileInputStream流对象和FileOutputStream流对象
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
//3. 通过相关流的方法，读取文件中的数据
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1){
for (int i = 0; i < len; i++) {
buffer[i] = (byte) (buffer[i] ^ 5);
}
fos.write(buffer,0, len);
}
System.out.println("解密成功");
//4. 关闭相关的流资源，避免出现内存泄漏
fos.close();
fis.close();
}
}
![[CVPR 2023:3D Gaussian Splatting：实时的神经场渲染]](https://img-blog.csdnimg.cn/direct/cdb3d156200147a8a2fa3b773a25d843.png)
