Java 基础面试题——IO 流,springboot 实战项目百度云
按单位
字节流:以字节为单位,可以读写所有数据
字符流:以字符为单位,只能读写文本数据
按功能
节点流:具有实际传输数据的读写功能
过滤流:在节点流的基础之上增强功能
字节流
//InputStream 字节输入流
public int read(){}
public int read(byte[] b){}
public int read(byte[] b, int off, int len){}
// OutputStream 字节输出流
public void write(int n){}
public void write(byte[] b){}
public void write(byte[] b, int off, int len){}
文件字节流
// 1 创建 FileInputStream 并指定文件路径
FileInputStream fis = new FileInputStream("d:\abc.txt");
// 2 读取文件
// fis.read();
// 3 关闭
fis.close();
===============================================================
// 1 创建文件字节输出流
FileOutputStream fos = new FileOutputStream("路径",
true);// true 表示不覆盖 接着写
// 2 写入文件
fos.write(97);
fos.write('a');
// 3 关闭
fos.close();
字节缓冲流
缓冲流:BufferedInputStream/ BufferedOutputStream
提高 IO 效率,减少访问磁盘次数
数据存储在缓冲区中,flush 是将缓冲区的内容写入文件中,也可以直接 close
// 1 创建 BufferedInputStream
FileInputStream fis = new FileInputStream("路径");
BufferedInputStream bis = new BufferedInputStream(fis);
// 3 关闭
bis.close();
对象流
ObjectOutputStream / ObjectInputStream
增强了缓冲区功能
增强了读写 8 种基本数据类型和字符串的功能
增强了读写对象的功能
readObject() 从流中读取一个对象
writeObject(Object obj) 向流中写入一个对象
使用流传输对象的过程称为序列化、反序列化
序列化
// 使用 objectoutputStream 实现序列化
psvm(String[] args){
// 1. 创建对象流
FileOutputStream fos = new FileOutputStream("d:\st.bin");
ObjectOutputSream oos = new objectOutputSream(fos);
// 2. 序列化(写入操作)
Student zhangsan = new Student("zs", 20);
oos.WriteObject(zhangsan);
// 3. 关闭
oos.close();
sout("序列化完毕");
}
反序列化
// 使用 ObjectInputSteam 实现反序列化(读取重构对象)
psvm(String[] args){
// 1. 创建对象流
FileInputStream fis = new FileInputStream("d:\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
// 2. 读取文件(反序列化)
Student s = (Student)ois.readObject();
// 3. 关闭
ois.close();
sout("执行完毕");
sout(s.toString());
}
序列化注意事项
某个类要想序列化必须实现 Serializable 接口
序列化类中对象属性要求实现 Serializable 接口
序列化版本号 ID,保证序列化的类和反序列化的类是同一个类
使用 transient 修饰属性,这个属性就不能序列化
静态属性不能序列化
序列化多个对象,可以借助集合来实现
字符流
// 传统字节流读取
psvm(String[] args){
// 1. 创建 FileInputStream 对象
FileInputSteam fis = new FileInputStream("路径");
// 2. 读取
int data = 0;
while((data = fis.read()) != -1){
sout((char)data);
}
// 3. 关闭
fis.close();
}
字符缓冲流
BufferedReader / BufferedWriter
高效读写、支持输入换行符、可一次写一行读一行
psvm(String[] args) throws Exception{
// 创建缓冲流
FileReader fr = new FileReader("..");
BufferedReader br = new BufferedReader(fr);
// 读取
// 1. 第一种方式
char[] buf = new char[1024];
int count = 0;
while((count = br.read(buf)) != -1){
sout(new String(buf, 0, count));
}
// 2. 第二种方式 一行一行读取
String line = null;
while((line = br.readLine()) != null){
sout(line);
}
// 关闭
br.close();
}
psvm(String[] args){
// 1. 创建 BufferedWriter 对象
FileWriter fw = new FileWriter("..");
BufferedWriter bw = new BufferedWriter(fw);
// 2. 写入
for(int i = 0; i < 10; i ++){
bw.write("写入的内容");
vw.newLine(); // 写入一个换行符
bw.flush();
}
// 3. 关闭
bw.close(); // 此时会自动关闭 fw
}
转换流
桥转换流 InputStreamReader / OutputStreamWriter
可将字节流转换为字符流
可设置字符的编码方式
psvm(String[] args) throws Exception{
// 1 创建 InputStreamReader 对象
FileInputStream fis = new FisInputStream("..");
InputStreamReader isr = new InputStreamReader(fis, "utf-8");
// 2 读取文件
int data = 0;
while((data = isr.read()) != -1){
sout((char)data);
}
评论