IO流（三）

原创

酋长不想学Java 2023-08-26 20:28:47 博主文章分类：Java基础 ©著作权

©著作权归作者所有：来自51CTO博客作者酋长不想学Java的原创作品，请联系作者获取转载授权，否则将追究法律责任

1、缓冲流

体系结构如下所示：

2、字节缓冲流

import java.io.*;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //创建对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\Java基础\\Test02\\aa\\name.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\Java基础\\Test02\\aa\\copy.txt"));

        //进行复制
        int len = 0;
        while ((len = bis.read()) != -1){
            bos.write(len);
        }

        //关闭资源
        bos.close();
        bis.close();

    }
}

3、字符缓冲流

特有的方法

4、转换流（字节流和字符流之间的桥梁）

作用：当字节流想要使用字符流中的方法时，需要使用到转换流。

现有如下需求：

//问题1
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.Charset;

public class Question1 {
    public static void main(String[] args) throws IOException {
        //创建对象并指定编码
        FileReader fr = new FileReader("F:\\Java基础\\Test02\\aa\\GBK.txt", Charset.forName("GBK"));

        //读取数据
        int len = 0;
        while ((len = fr.read()) != -1){
            System.out.print((char) len);
        }

        //关闭资源
        fr.close();
    }
}

//问题2
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;

public class Question2 {
    public static void main(String[] args) throws IOException {
        //创建对象并关联文件
        FileWriter fw = new FileWriter("F:\\Java基础\\Test02\\aa\\GBK.txt", Charset.forName("GBK"));

        //写入数据
        fw.write("你好你好呀");

        //关闭资源
        fw.close();
    }
}

//问题3
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;

public class Question3 {
    public static void main(String[] args) throws IOException {
        //创建对象关联对象并指定字符集
        FileReader fr = new FileReader("F:\\Java基础\\Test02\\aa\\GBK.txt", Charset.forName("GBK"));
        FileWriter fw = new FileWriter("F:\\Java基础\\Test02\\aa\\utf-8.txt", Charset.forName("utf-8"));

        //边读边写
        int ch = 0;
        while ((ch = fr.read()) != -1) {
            fw.write(ch);
        }

        //关闭资源
        fw.close();
        fr.close();


    }
}

jdk11之前的方法：

问题4：使用字节流（字节流是没有读取一行的方法的）读取文件中的数据，每次读取一行，而且不能出现乱码。

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Question4 {
    public static void main(String[] args) throws IOException {
        //InputStreamReader表示将字节流转换为字符流，然后再转换为高级缓冲流
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("F:\\Java基础\\Test02\\aa\\utf-8.txt")));

        //直接调用高级缓冲流中的方法
        String str = null;
        while ((str = br.readLine()) != null){
            System.out.println(str);
        }

        //关闭资源
        br.close();

    }
}

总结内容：

5、序列化流（可以把java中的对象写到本地文件中）

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //创建学生的对象
        Student stu = new Student("张三", 21);

        //创建序列化流并且关联文件
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:\\Java基础\\Test02\\aa\\Student.txt"));

        //将数据写入到文件中，注意这个类需要实现Serializable接口
        oos.writeObject(stu);

        //关闭资源
        oos.close();

    }
}

6、反序列化流

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Test2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:\\Java基础\\Test02\\aa\\Student.txt"));
        //读取数据
        Object o = ois.readObject();
        //打印对象
        System.out.println(o);
        //关闭资源
        ois.close();

    }
}

使用序列化的一些细节：

①、需要给类添加序列号，不然如果修改了类，那么在反序列化的时候就会报错

②、如果不想给某个属性序列化到本地文件，那么就给这个属性添加transient关键词，如下所示：
private transient String address;

读多个对象：

首先在把对象写入文件的时候就要通过集合的方式写入，如下所示：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Collections;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //创建学生的对象
        Student stu1 = new Student("张三", 21);
        Student stu2 = new Student("李四", 22);
        Student stu3 = new Student("王五", 25);

        //将上面的学生对象放进一个集合中
        ArrayList<Student> list = new ArrayList<>();
        Collections.addAll(list, stu1, stu2, stu3);

        //创建序列化流并且关联文件
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:\\Java基础\\Test02\\aa\\Student1.txt"));

        //然后直接将集合写入文件中
        oos.writeObject(list);


        //关闭资源
        oos.close();

    }
}

然后读取的时候再按照集合的方式读取出来：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

public class Test3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建对象并关联文件
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:\\Java基础\\Test02\\aa\\Student1.txt"));

        //读取数据，直接读取集合，需要进行强制类型转换
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();

        //对集合进行遍历
        for (Student student : list) {
            System.out.println(student);
        }

        //关闭资源
        ois.close();
    }
}