IO流（二）

四、数据流

接下我们再学习一种流，这种流在开发中偶尔也会用到。比如，我们想把数据和数据的类型一并写到文件中去，读取的时候也将数据和数据类型一并读出来。这就可以用到数据流，有两个DataInputStream和DataOutputStream.

4.1 DataOutputStream数据输出类

我们先学习DataOutputStream类，它也是一种包装流，创建DataOutputStream对象时，底层需要依赖于一个原始的OutputStream流对象。然后调用它的wirteXxx方法，写的是特定类型的数据。

它允许把数据和其类型一并写出去。

代码如下：往文件中写整数、小数、布尔类型数据、字符串数据

public class DataOutputStreamTest {
    public static void main(String[] args) {
        try (
                // 创建一个数据输出流包装低级的字节输出流
            DataOutputStream dos =
                    new DataOutputStream(new FileOutputStream("day12_io\\src\\sy07.txt"));
        ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("柳岩666！");
            /**
             * 注意:
             *  保存的内容不是乱码, 它是一种特殊的数据存储方式
             *  这些数据不是为了给你看的, 是为了存进去后下次用时方便恢复的
             */
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.2 DataInputStream数据输入类

学习完DataOutputStream后，再学习DataIntputStream类，它也是一种包装流，创建DataInputStream对象时，底层需要依赖于一个原始的InputStream流对象。然后调用它的readXxx()方法就可以读取特定类型的数据。

它用于读取数据输出流写出去的数据。

代码如下：读取文件中特定类型的数据（整数、小数、字符串等）

public class DataInputStreamTest {
    public static void main(String[] args) {
        try (
                // 创建数据输入流 包装 低级的 字节输入流
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("day12_io\\src\\sy07.txt"));
        ){
            // 按照顺序读取
            int i = dis.readInt();
            System.out.println(i);
​
            double d = dis.readDouble();
            System.out.println(d);
​
            boolean b = dis.readBoolean();
            System.out.println(b);
​
            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

五、序列化流

各位同学同学，还有最后一个流要学习，叫做序列化流。序列化流是干什么用的呢？ 我们知道字节流是以字节为单位来读写数据、字符流是按照字符为单位来读写数据、在不久的将来可能需要把Java对象为单位来读写数据。也就是把对象当做一个整体，可以写一个对象到文件，也可以从文件中把对象读取出来。

这里有一个新词 序列化，第一次听同学们可能还比较陌生，我来给同学们解释一下

序列化：意思就是把Java对象写到文件或者网络中去存起来。（简单记：写对象）
反序列化：意思就是把Java对象从文件或者网络中读取出来。（简单记：读对象）

5.1 ObjectOutputStream类

接下来，先学习ObjectOutputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输出流使用。

序列化：意思就是把Java对象写到文件或者网络中去存起来。（简单记：写对象）

注意：对象如果要参与序列化，必须实现序列化接口（java.io.Serializable）

代码如下：将一个User对象写到文件中去

• 第一步：先准备一个User类，必须让其实现Serializable接口。

// 注意：对象如果需要序列化，必须实现序列化接口。
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    // transient 这个成员变量将不参与序列化。
    private transient String passWord;
​
    public User() {
    }
​
    public User(String loginName, String userName, int age, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }
​
    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}

• 第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。

public class ObjectOutputStreamTest {
    public static void main(String[] args) {
        try (
                // 2. 创建一个对象字节输出流包装原始的字节 输出流。
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("day12_io\\src\\sy08.txt"));
        ){
            // 1. 创建一个Java对象。
            User u = new User("admin", "柳岩", 32, "666888xyz");
​
            // 3. 序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！！");
​
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：写到文件中的对象，是不能用记事本打开看的。因为对象本身就不是文本数据，打开是这种形式，这是一种特殊的存储方式

怎样才能读懂文件中的对象是什么呢？这里必须用反序列化，自己写代码读。

5.2 ObjectInputStream类

接下来，学习ObjectInputStream流，它也是一个包装流，不能单独使用，需要结合原始的字节输入流使用。

反序列化：意思就是把Java对象从文件或者网络中读取出来。（简单记：读对象）

接着前面的案例，文件中已经有一个Student对象，现在要使用ObjectInputStream读取出来。称之为反序列化。

public class ObjectInputStreamTest {
    public static void main(String[] args) {
        try (
            // 1. 创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day12_io\\src\\sy08.txt"));
        ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1. 对象序列化的含义是什么？怎么实现对象序列化？需要注意什么？
    把对象数据存入到文件中去。
    对象字节输出流ObjectOutputStram
    public void writeObject(Object obj)
    对象必须实现序列化接口
    
2. 对象反序列化的含义是什么？怎么实现对象反序列化？
    把对象数据存入到文件中去。
    对象字节输入流ObjectInputStram
    public Object readObject()
    
3. 如果要一次性序列化多个对象, 怎么做呢?
    用一个ArrayList集合存储多个对象，然后直接对集合进行序列化即可
    注意：ArrayList集合已经实现了序列化接口！

六、补充知识：IO框架

最后，再给同学们补充讲解一个知识，叫做IO框架。它有什么用呢？

解决某类问题，编写的一套类、接口等，可以理解成一个半成品，大多框架都是第三方研发的。
好处：
    在框架的基础上开发，可以得到优秀的软件架构，并能提高开发效率
框架的形式：
    一般是把类、接口等编译成class形式，再压缩成一个.jar结尾的文件发行出去。
​
什么是IO框架?
    封装了Java提供的对文件、数据进行操作的代码，对外提供了更简单的方式来对文件进行操作，对数据进行读写等。

有同学经常问老师，我们只学习了IO流对文件复制，能不能复制文件夹呀？

当然是可以咯，但是如果让我们自己写复制文件夹的代码需要用到递归，还是比较麻烦的。为了简化对IO操作，由apache开源基金组织提供了一组有关IO流小框架，目的是提高IO流的开发效率。

这个框架的名字叫commons-io：其本质是别人写好的一些字节码文件（class文件），打包成了一个jar包。我们只需要把jar包引入到我们的项目中，就可以直接用了。

这里给同学们介绍一个jar包中提供的工具类叫FileUtils，它的部分功能如下，很方便，你一看名字就知道怎么用了。

在写代码之前，先需要引入jar包，具体步骤如下

1. 在模块的目录下，创建一个文件夹：lib
2. 将commons-io-2.17.jar文件复制到lib文件夹下
3. 选择lib下的jar包，右键点击，选择 Add as Library -> 点击OK，然后就可以用了。
4. 在类中导包使用

代码如下：

public class CommonsIOTest {
    public static void main(String[] args) throws Exception {
        // 1.复制文件
        FileUtils.copyFile(new File("day12_io\\src\\sy01.txt"), new File("day12_io\\src\\sy01_copy.txt"));
​
        // 2.复制文件夹
        FileUtils.copyDirectory(new File("D:\\resource\\秘密"), new File("D:\\resource\\秘密2"));
​
        // 3.删除文件夹
        FileUtils.deleteDirectory(new File("D:\\resource\\秘密2"));
​
        // Java提供的原生的一行代码搞定很多事情
        Files.copy(Path.of("day12_io\\src\\sy05.txt"), Path.of("day12_io\\src\\sy05_copy.txt"));
        System.out.println(Files.readString(Path.of("day12_io\\src\\sy01.txt")));
    }
}

以上就是今天所讲内容;