1 IO介绍以及分类
IO: Input Output
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作
1.1 IO流的分类
1. 根据处理的数据类型不同可以分为：字符流和字节流。
2. 根据数据的流向不同可以分为：输入流和输出流。
1.2 字节流（Byte Stream）
1.字节流以字节为单位进行读取和写入操作，适合处理二进制数据（如图片、视频、音频等）或者文本文件。
2.字节流类通常以 InputStream 和 OutputStream 结尾，例如 FileInputStream、FileOutputStream。
3.字节流可以用于读写任何类型的文件，但对于文本文件的处理可能需要做字符编码转换。
1.3 字符流（Character Stream）
1.字符流以字符为单位进行读取和写入操作，适合处理文本数据。字符流会自动处理字符编码转换，避免了字节流在处理文本时可能出现的乱码问题。
2.字符流类通常以 Reader 和 Writer 结尾，例如 FileReader、FileWriter。
3.字符流适合处理文本文件，能够更方便地读写文本中的字符数据。
1.4 选择建议
1.如果你需要处理文本文件，推荐使用字符流，因为它们能够更好地处理字符编码和文本数据。
2.如果需要处理二进制文件或者未经处理的数据，应该使用字节流。
2 字符流
@Test
public void test1() {
FileReader fileReader = null;//声明放在外边 局部变量必须初始化
//FileReader fileReader;//声明放在外边 ×××××
try {
fileReader = new FileReader("io.txt");//打开水龙头
//Reads a single character.
int ch1 = fileReader.read();
System.out.println((char)ch1);//a
int ch2 = fileReader.read();
System.out.println((char)ch2);//b
int ch3 = fileReader.read();
System.out.println((char)ch3);//c
int ch4 = fileReader.read();
System.out.println((char)ch4);//
System.out.println(ch4);//-1
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {//在finally里边必须关闭IO流
try {
fileReader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
@Test
public void test2() {
try {
FileReader fileReader = new FileReader("io.txt");
int ch = -1;
while ((ch = fileReader.read()) != -1) {
System.out.println((char)ch);
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
//----------Day12---------------
@Test
public void test3() {
try {
FileReader fileReader = new FileReader("io.txt");
char[] buffer = new char[10];
int length = -1;
//public int read(char[] cbuf)
//一次将10个字符读入到buffer数组里面
//返回：读取的字符数，如果已经达到流的末尾，返回-1
while ((length = fileReader.read(buffer)) != -1) {
System.out.println(length);
System.out.println(buffer);
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Test
public void test4() {
//父类
FileReader fileReader = null;
FileWriter fileWriter = null;
try {
fileReader = new FileReader("io.txt");
fileWriter = new FileWriter("io_back.txt");
char[] buffer = new char[10];
int length = -1;
//public int read(char[] cbuf)
//一次将10个字符读入到buffer数组里面
//返回：读取的字符数，如果已经达到流的末尾，返回-1
while ((length = fileReader.read(buffer)) != -1) {
System.out.println(length);
System.out.println(buffer);
//读出多少写多少，最后一次读出来的数据很有可能不够buffer数组的长度
fileWriter.write(buffer, 0, length);
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//先打开的后关闭
if (fileWriter != null) {
try {
fileWriter.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
if (fileReader != null) {
try {
fileReader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
3 字节流
@Test
public void test5() {
//FileInoutSteam 父类是InputSteam
FileInputStream fileInputStream = null;//经验 先生命成null 局部变量必须初始化
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream("baidu.png");
fileOutputStream = new FileOutputStream("baidu_back.png");
byte[] buffer = new byte[1024];
int length = -1;
while ((length = fileInputStream.read(buffer)) != -1){//赋值语句有结果 结果就是length值
System.out.println(length);
//fileOutputStream.write(buffer, 0, length);//这个不会多写
fileOutputStream.write(buffer);//会多写几个字节
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (fileOutputStream != null) {
try {
fileOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
4 对象流
ObjectInputStream、ObjectOutputStream
将对象写入文件的操作流ObjectOutputStream，称为序列化。
从流中读取对象的操作流程ObjectInputStream，称为反序列化。
java.io.NotSerializableException: com.situ.day13.Student
Serialize：序列化
/*
* 适度编码益脑，沉迷编码伤身，合理安排时间，享受快乐生活。
* Copyright @TangXJ
* Created by TangXJ
* Created&Used date: 2024/3/27 下午2:06 ~ 2024/3/27 下午3:39
* Modified date: 2024/3/27 下午3:39
*/
package com.sdust.day12;
import org.junit.Test;
import java.io.*;
public class Student implements Serializable {//实现一个接口
private Integer id;
private String name;
private Integer age;
private String gender;
public Student() {
}
public Student(Integer id, String name, Integer age, String gender) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
'}';
}
//对象流
@Test
public void test1() {
Student student = new Student();
student.setId(1);
student.setName("zhangsan");
student.setAge(23);
student.setGender("男");
//java.lang.RuntimeException: java.io.NotSerializableException: com.sdust.day12.Student//不能序列化的异常
//实现一个接口
ObjectOutputStream objectOutputStream = null;//不负责写文件 对象转换交给它ObjectOutputStream来完成
//负责把一个对象 做一个转换
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream("stu");
objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(student);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {//x先打开的后关闭
if (objectOutputStream != null){
try {
objectOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
if (fileOutputStream != null) {
try {
fileOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
@Test
public void test2() {
ObjectInputStream objectInputStream = null;
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream("stu");
objectInputStream = new ObjectInputStream(fileInputStream);
//Student student = objectInput.readObject();//报错 父类不能转换为子类
//Object object = new Student();
Student student = (Student) objectInputStream.readObject();
System.out.println(student);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} finally {
if (objectInputStream != null) {
try {
objectInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}
这个Demo运行时要注释掉所有构造函数。
一般情况下：先打开的后关闭，后打开的先关闭。
另一种情况：看依赖关系，如果流A依赖于流B，先关闭流A，再关闭流B。
