Java学习46-Java 流(Stream)、文件(File)和IO - 数据流和对象流的使用

Dear_喜阳阳

于 2024-04-16 17:23:16 发布

阅读量750

点赞数 10

文章标签： java 学习 php

本文链接：https://blog.csdn.net/weixin_42892630/article/details/137833025

版权

Q：如果想要将内存中定义的变量(包括基本数据类型或引用数据类型)保存在文件中，怎么办？

int age = 17;
char gender = "男";
int amount =5000;
double price = 75.5;
boolean relive = true;

String name = "";
Student stu = new Student("小丽",23, 04553)

A：可以使用 数据流 or 对象流进行 [变量->文件] 存储。

数据流 DataOutputStream，DataInputStream

数据流及其作用(由于限制条件过多，现在基本不用了，了解一下就行)
数据流
DataOutputStream：可以将内存中的基本数据类型的变量，String类型的变量写出到具体的文件中。
DataInputStream：将文件中保存的数据还原为内存中的基本数据类型的变量，String类型的变量。

对象流DataInputStream中的方法:

byte readByte()
short readShort()
int readInt()
long readLong
float readFloat()
double readDouble()
char readChar()
boolean readBoolean()
String readUTF()
void readFully(byte[] b)

数据流DataOutputStream中的方法:将上面所有的read改为write即可。

数据流的弊端：DataInputStream/DataOutputStream只支持Java基本数据类型和字符串的读写，而不支持其他Java对象的类型。而ObjectOutputStream和ObjectInputStream仅仅支持Java基本数据类型的数据读写，又支持Java对象的读写，所以重点介绍对象流ObjectOutputStream 和 ObjectInputStream。

对象流 ObjectInputStream 和 ObjectOutputStream

对象流及其作用
2.1 API：
ObjectInputStream
ObjectOutputStream

2.2 作用：
可以读写基本数据类型的变量，引用数据类型的变量。

对象的序列化机制是什么
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上。
或通过网络将这种二进制流传输到另一个网络节点。// 而其他程序获取了这种二进制流，就可以恢复成原来的Java对象。
如下两个过程使用的流
序列化过程：使用 ObjectOutputStream流实现。将内存中的Java对象保存在文件中或通过网络传输出去。
反序列化过程：使用 ObjectInputStream流实现。将文件中的数据或网络中传输过来的数据还原为内存中的Java对象。
自定义类要实现序列化机制，需要满足

自定义类需要实现接口：Serializable
要求自定义类声明一个全局变量: static final long serialVersionUID = 42234234L; 用来唯一的标识当前的类。
//这个数字是程序员自定义的，以L结尾。也可以在前面加上private即private static final long serialVersionUID = 随便的数字42666L;都可以。更多关于static final long serialVersionUID 的设置的设置，打开Serializable.java文件查看最上面的注释。
要求自定义的各个属性也必须是可序列化的。

对于基本数据类型的属性，默认就是可以序列化的
对于引用数据类型的属性，要求实现Serializable接口

注意点：
1.如果不声明全局变量serialersionUID系统会自动声明一个针对于当前类的SerialVersionUID。如果修改此类的话，会导致serialVersionUID变化，进而导致反序列化时，出现InvalidClassException异常。
类中的属性如果声明为transient或static则不会实现序列化(简单说就是这些项目的值不会保存在文件中，等你想从文件中反序列化的时候，是读取不到保存信息的，因为刚刚原始值就没序列化进去。) 详见下面的例子：

ObjectInputOutputStream.java文件

package IOTest;
import IOTest.Person.Account;
import org.junit.Test;

import java.io.*;
public class ObjectInputOutputStream {

    @Test
    public void test1() throws IOException {

        /*
         * 序列化过程：使用ObjectOutputStream流实现。
         * 将内存中的Java对象，保存在文件中(或通过网络传输出去)。
         * */


        //1. 创建对象的过程，File对象，和流的对象
        File f1 = new File("object1.txt"); //这里的名字随意起，可以叫object1.ber/object1.dat都无所谓。
        //这里是一个处理流，需要包裹一个现有的处理流，所以用了FileOutputStream修饰f1
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(f1));

        //2.写出数据，即为序列化的过程。

        oos.writeUTF("这是内存写入文件的一句话。只是用于UTF编码的字符串的序列化");
        oos.flush();

        oos.writeObject("第二句写什么好呢？为了个体的平安喜乐，更为了人类世界的进步！这一句用于Java对象的序列化。");
        oos.flush();

        oos.close();
    }

        /*
        * 反序列化过程：使用 ObjectInputStream流实现。
        * 将文件中的数据或网络中传输过来的数据 还原为内存中的Java对象。
        * */
    @Test
        public void test2() throws IOException, ClassNotFoundException {

            //1. 创建对象的过程，File对象，和流的对象
            File f1 = new File("object1.txt");
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f1));
            //2.读取文件中的对象(或称为 反序列化的过程)

            String str1 = ois.readUTF();
            System.out.println(str1);

            String str2 = (String) ois.readObject();
            System.out.println(str2);
            //3.关闭资源
            ois.close();


    }

    /*
     * 演示自定义类的对象 序列化 和 反序列化的过程
     *
     * 自定义类的序列化举例
     * */
    @Test
    public void test3() throws IOException {
        //1. 序列化过程
        File f1 = new File("pers1.dat");//名字随便起
        ObjectOutputStream oos1= new ObjectOutputStream(new FileOutputStream(f1));

        //2. 写出数据，即为序列化的过程
        Person p1 = new Person("Ella",6, 60123);
        //Person p1 = new Person("Ella",6);
        oos1.writeObject(p1);
        oos1.flush();


        Person p2 = new Person("Alice",3,30122,new Account(1000000));
        oos1.writeObject(p2);
        oos1.flush();
        //3. 关闭资源
        oos1.close();

    }



    /*
    *
    * 演示自定义类的对象 反序列化的过程
    *
    * 自定义类的反序列化（从文件中写到内存里）：
    * */
    @Test
    public void test4() throws IOException, ClassNotFoundException {

        File f1 = new File("pers1.dat");
        ObjectInputStream ois1 = new ObjectInputStream(new FileInputStream(f1));
        //Person p1 = new Person();
        //p1= (Person) ois1.readObject();

        Person p1 = (Person) ois1.readObject();

        //System.out.println(p1.toString()); //可以用这个写
        System.out.println(p1); //也可以用这个写
        //在Java中，System.out.println(p1.toString()); 和 System.out.println(p1); 这两行代码的功能在大多数情况下是相同的，
        // 它们都会输出p1对象的字符串表示。
        // 这主要是因为System.out.println()方法内部会调用传入对象的toString()方法。

        Person p2 = (Person) ois1.readObject();
        System.out.println(p2);


        ois1.close();


    }
}

下面是Person.java文件,当前文件中不含有声明为transient或static的变量，请观察程序的输出：



package IOTest;

import java.io.Serializable;


/*
* 为什么要写implements Serializable?
* 如果不写，会出现错误：java.io.NotSerializableException: IOTest.Person
* 这个错误表示你尝试序列化一个类（在这个例子中是 IOTest.Person 类），
* 但是这个类没有实现 java.io.Serializable 接口。
* 在Java中，要序列化一个对象，该对象的类必须实现 Serializable 接口，
* 否则当你尝试将该对象写入到输出流（如 ObjectOutputStream）时，就会抛出 NotSerializableException 异常。
*
* 这类接口，就叫标识接口
* */
public class Person implements Serializable { //Serializable属于一个标识接口



    static final long serialVersionUID = 676600868485450L;
    // 上面的serialVersionUID可以随便写个数字,这个编码类似密码一样，注意一定要自己定义。
    // 如果自己不定义，系统会在后台帮你默认定义一个serialVersionUID编码，用于序列化+反序列化。
    // 这样很危险，因为一旦自定义类的代码被改写，系统就会重新生成一个新的serialVersionUID编码
    // 就会造成序列化用着一个“密码”，反序列化用着一个新的“密码”，运行起来就会直接报错。
    String name;
     int age;

     long id;

     Account acct ;

    public Person() {
    }

    public Person(String name, int age, long id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public Person(String name, int age, long id, Account acct) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.acct = acct;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
         this.id = id;
     }


    static class Account implements Serializable {
        double balance;

        static final long serialVersionUID = 6766005450L;
        public Account(double balance) {
            this.balance = balance;
        }

        @Override
        public String toString() {
            return "Account{" +
                    "balance=" + balance +
                    '}';
        }
    }

   @Override
   public String toString() {
       return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", id=" + id +
               ", acct=" + acct +
               '}';
   }

}

运行结果：

Person{name='Ella', age=6, id=60123, acct=null}
Person{name='Alice', age=3, id=30122, acct=Account{balance=1000000.0}}

Process finished with exit code 0

修改Person.java文件，声明age和id为transient或static时候，观察输出结果：

package IOTest;

import java.io.Serializable;


/*
* 为什么要写implements Serializable?
* 如果不写，会出现错误：java.io.NotSerializableException: IOTest.Person
* 这个错误表示你尝试序列化一个类（在这个例子中是 IOTest.Person 类），
* 但是这个类没有实现 java.io.Serializable 接口。
* 在Java中，要序列化一个对象，该对象的类必须实现 Serializable 接口，
* 否则当你尝试将该对象写入到输出流（如 ObjectOutputStream）时，就会抛出 NotSerializableException 异常。
*
* 这类接口，就叫标识接口
* */
public class Person implements Serializable { //Serializable属于一个标识接口



    static final long serialVersionUID = 676600868485450L;
    // 上面的serialVersionUID可以随便写个数字,这个编码类似密码一样，注意一定要自己定义。
    // 如果自己不定义，系统会在后台帮你默认定义一个serialVersionUID编码，用于序列化+反序列化。
    // 这样很危险，因为一旦自定义类的代码被改写，系统就会重新生成一个新的serialVersionUID编码
    // 就会造成序列化用着一个“密码”，反序列化用着一个新的“密码”，运行起来就会直接报错。
    String name;
     static int age; //定义为static，静态的，无法正常序列化，等到反序列化则输出为0或者null

     transient long id; //定义为transient，瞬态的，无法正常序列化，等到反序列化则输出为0或者null

     Account acct ;

    public Person() {
    }

    public Person(String name, int age, long id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public Person(String name, int age, long id, Account acct) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.acct = acct;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
         this.id = id;
     }



    static class Account implements Serializable {
        double balance;

        static final long serialVersionUID = 6766005450L;
        public Account(double balance) {
            this.balance = balance;
        }

        @Override
        public String toString() {
            return "Account{" +
                    "balance=" + balance +
                    '}';
        }
    }


   @Override
   public String toString() {
       return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", id=" + id +
               ", acct=" + acct +
               '}';
   }

}

输出结果可见，age=0, id=0 正如我们所料，反序列化时候这两项的值返回0或者null：

Person{name='Ella', age=0, id=0, acct=null}
Person{name='Alice', age=0, id=0, acct=Account{balance=1000000.0}}

Process finished with exit code 0

Dear_喜阳阳

关注

10
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
Java学习46-Java 流(Stream)、文件(File)和IO - 数据流和对象流的使用

Q：如果想要将内存中定义的变量(包括基本数据类型或引用数据类型)保存在文件中，怎么办？A：可以使用数据流or对象流进行 [变量->文件] 存储。
复制链接

扫一扫