Java学习【IO流：深入理解与应用（上）】
- 🍃1.IO流体系结构
- 🍃2.FileOutputStream
- 🍁2.1FileOutputStream写数据的三种方式
- 🍁2.2换行和续写
- 🍃3.FileInputStream
- 🍁3.1每次读取一个字节
- 🍁3.2读取多个字节
- 🍃文件拷贝
- 🍃IO流中的异常处理方式
🚀所属专栏：Java学习⭐⭐
🚀欢迎互三👉： 2的n次方_⭐⭐
🍃1.IO流体系结构
在Java编程中，IO（Input/Output）流是一个非常重要的概念，它允许我们与各种数据源（如文件、网络、内存等）进行交互。Java的IO库提供了丰富的类和方法，用于读取和写入数据。
IO流按照操作文件类型又可以分为
字节流：可以操作所有类型文件
字符流：只能操作纯文本文件
由于上面的四个都是抽象类，在实现的时候要创建子类的对象，这里以字节流为例，下面是其两个子类
🍃2.FileOutputStream
FileOutputStream:操作本地文件的字节输出流，可以把程序中的数据写入到本地文件中。
1.参数是字符串表示的路径或者File对象都可以
2.如果文件不存在就会创建一个新的文件，但是要保证父级路径是存在的
3.如果文件存在，那么会清空文件中的数据，然后再写入
写入文件时，传入参数是整数，会转换为ASCII码对应的字符
如果想要写入整型，就分开写对应的ASCII码
🍁2.1FileOutputStream写数据的三种方式
创建对象之后是通过调用write()方法进行写入
FileOutputStream fos = new FileOutputStream("E:\\java\\a.txt");
// 写入一个数据
fos.write(97);
这里会出现异常，将异常进行抛出处理
write()也提供了其他的重载方法
可以传入一个byte类型的数组，写入多个字节，还可以指定写入的起始索引，再指出写入几个字节
byte[] bytes = {97, 98, 99, 100};
fos.write(bytes);
//从1索引开始写入两个字符
fos.write(bytes, 1, 2);
每次执行操作结束之后都要调用close()方法进行资源释放，否则文件就会一直被占用
public class ByteStreamDemo1 {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("E:\\java\\a.txt");
// 写入一个数据
fos.write(97);
//写入多个数据
byte[] bytes = {97, 98, 99, 100};
fos.write(bytes);
//从1索引开始写入两个字符
fos.write(bytes, 1, 2);
//释放资源，解除资源占用
fos.close();
}
}
🍁2.2换行和续写
除了以上三种写入方式外，还可以通过字符串的方式进行写入
此外，如果需要写入换行，在windows操作系统中，是用 “\r\n” 表示换行
public class ByteStreamDemo1 {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("E:\\java\\a.txt");
//写入字符串
String str = "hello";
byte[] bytes1 = str.getBytes();
fos.write(bytes1);
//写入换行
String s = "\r\n";
fos.write(s.getBytes());
fos.write(97);
//释放资源，解除资源占用
fos.close();
}
}
打开记事本查看a.txt的内容
续写就是不清空原来文件的内容，接着往下写
FileOutputStream()的构造方法还有一个boolean类型的参数，表示续写开关，默认是false，如果创建对象时给出true，那么就表示续写，此时就不会清空原来文件的内容
public class ByteStreamDemo1 {
public static void main(String[] args) throws IOException {
//续写，之前内容不会清空
FileOutputStream fos1 = new FileOutputStream("E:\\java\\a.txt", true);//打开续写
fos1.write("666".getBytes());
//释放资源
fos1.close();
}
}
可以看出，这次是接着上次的内容继续进行写入的
🍃3.FileInputStream
操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中来
🍁3.1每次读取一个字节
第一步也是创建对象，接着调用read()方法，就可以读取到一个字节的内容，读到的内容也是ASCII码对应的数字
public class ByteStreamDemo2 {
public static void main(String[] args) throws IOException {
//字节输出入流，如果文件不存在，就会报错
FileInputStream fis = new FileInputStream("E:\\java\\a.txt");
//读取一个字节，读取到末尾再继续读会返回-1
int res = fis.read();
System.out.println((char) res);
//释放资源
fis.close();
}
}
创建对象时，如果对应路径不存在，就会直接报错，此外，读取到末尾之后继续读就会返回-1，那么文件中最后确实是-1的话怎么判断呢？“-1"其实是分为”-" 和 "1"的，所以并不冲突
根据这个特性可以进行文件的循环读取
int a = 0;
while ((a = fis.read() )!= -1){
System.out.print((char)a);
}
System.out.println();
问题：如果不用一个变量来接收行不行？
while(fis.read() != -1){
System.out.println((char)fis.read());
}
答：因为每次调用read就表示往后移动一位，所以每次循环都进行了两次读取（判断条件一次，输出语句一次），打印的数据其实是跳跃的
🍁3.2读取多个字节
如果要读取多个字节，可以在read方法中传入一个byte类型的数组，数组长度是多少每次就读几个字节
public class ByteStreamDemo2 {
public static void main(String[] args) throws IOException {
//字节输出入流，如果文件不存在，就会报错
FileInputStream fis = new FileInputStream("E:\\java\\a.txt");
//读取多个字节
byte[] byte1 = new byte[3];
int len1 = fis.read(byte1);
System.out.println(new String(byte1));
System.out.println(len1);
//如果继续往下读，因为文件中剩余的数据不足数组的长度，只覆盖读取到了的数据
int len2 = fis.read(byte1);
System.out.println(new String(byte1));
System.out.println(new String(byte1,0,len2));//只打印读到的数据
System.out.println(len2);
//释放资源
fis.close();
}
}
如果继续往下读，文件中剩余的数据不足数组的长度，只覆盖读取到的数据，此时就可以把读取的字节数进行一个返回，只打印读取到的数据，也就是没有被覆盖的数据不打印
🍃文件拷贝
文件拷贝就是把读取和写入结合起来，把读取到的数据再写入另一个文件中，所以也有两种方式进行拷贝，一种是一个字节一个字节的拷贝，另一种就是直接定义一个大容量的数组，一次拷贝完成，很显然，后者更加高效
public class ByteStreamDemo3 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("E:\\java\\a.txt");
FileOutputStream fos = new FileOutputStream("E:\\java\\b.txt");
//一次拷贝一个字节
int b1 = 0;
while ((b1 = fis.read()) != -1) {
fos.write(b1);
}
//一次拷贝多个字节
byte[] b2 = new byte[1024];
int len = 0;
while((len = fis.read(b2)) != -1){
fos.write(b2,0,len);
}
//释放资源，先开后关
fos.close();
fis.close();
}
}
最后释放资源的时候需要注意，遵循最先打开的文件最后关闭的原则
🍃IO流中的异常处理方式
在之前，我们都是对异常进行抛出处理，怎么去使用try - catch处理呢？
首先需要明白，程序最后都要进行资源释放，所以就可以采用try - catch - finally结构，把资源释放的模块放在finally里
如果按照正常的想法，把有异常的模块都放进try里，此时创建出的对象就属于局部变量，finally里调用不了，就需要把创建对象的部分写在外面
但此时还是报错了，还需要对finally的内容进行异常处理
这样看貌似是没有问题了，但是还是有一个细节需要注意，如果创建对象时给的路径不存在，还是会报错，除了正常给出的路径异常，还有一个空指针异常
就需要处理对象为空的情况
public class ByteStreamDemo4 {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("E:\\java\\a.txt");
fos = new FileOutputStream("E:\\java\\b.txt");
//一次拷贝多个字节
byte[] b = new byte[1024];
int len = 0;
while ((len = fis.read(b)) != -1) {
fos.write(b, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//释放资源，先开后关
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
此时再运行就没有空指针异常了
上面的代码看起来很多，在JDK7和JDK9种给出了两种简化版本，推出了AutoCloseable接口，它定义了一个可以被自动关闭的资源，确保在 try 代码块执行完毕后，资源能够自动关闭，即使发生了异常，但是只能在特定的情况可以使用
JDK7:
JDK9:
这样就不用在finally种写一堆对释放资源处理的异常了，不过，一般情况下直接抛出就可以了
