java对象序列化前后大小（java对象的序列化和反序列化）

发布时间：2022-11-15

本文目录一览：

  1. Java对象怎么序列化和反序列化
  2. [JAVA 对象序列化问题，高手求教！](#JAVA 对象序列化问题，高手求教！)
  3. java对象序列化问题
  4. java中为什么要进行对象序列化？
  5. Java中对象序列化的作用是什么？全面一点，谢谢
  6. 为什么JAVA对象需要实现序列化

Java对象怎么序列化和反序列化

import java.io.Serializable;
/*
 * NotSerializableException:未序列化异常
 *
 * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
 * 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。
 *
 * java.io.InvalidClassException:
 * cn.itcast_07.Person; local class incompatible:
 * stream classdesc serialVersionUID = -2071565876962058344,
 * local class serialVersionUID = -8345153069362641443
 *
 * 为什么会有问题呢?
 * Person类实现了序列化接口，那么它本身也应该有一个标记值。
 * 这个标记值假设是100。
 * 开始的时候：
 * Person.class -- id=100
 * wirte数据： oos.txt -- id=100
 * read数据: oos.txt -- id=100
 *
 * 现在：
 * Person.class -- id=200
 * wirte数据： oos.txt -- id=100
 * read数据: oos.txt -- id=100
 * 在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?
 * 回想一下原因是因为它们的id值不匹配。
 * 每次修改java文件的内容的时候,class文件的id值都会发生改变。
 * 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。
 * 但是呢，如果有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?
 * 不会。现在的关键是我如何能够知道这个id值如何表示的呢?
 * 不用担心，不用记住，也没关系，点击鼠标即可。
 * 难道没有看到黄色警告线吗?
 *
 * 要知道的是：
 * 看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。
 * 而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。
 *
 * 注意：
 * 一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?
 * 使用transient关键字声明不需要序列化的成员变量
 */
public class Person implements Serializable {
    private static final long serialVersionUID = -2071565876962058344L;
    private String name;
    // private int age;
    private transient int age;
    // int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

JAVA 对象序列化问题，高手求教！

我查了java的JDK帮助文档，发现没有关于readObject()函数是否读到文件末尾的判断方法，后来问了老师后说是可以在序列化输出文件的时候在多输出一个特定的类对象，如一个空对象，然后每次读一个对象之后先判断该对象是否满足你指定的条件，如果不满足则继续往下读，否则退出while循环。这也是一种编程的技巧。

java对象序列化问题

你可以参考以下程序中序列化的方法将你图片封装到一个类中，然后让此类实现Serializable接口。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
 *
 * @author top
 */
public class Inout {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws Exception {
        // TODO code application logic here
        Student student1 = new Student("top_beidu", 23, 99.9f);
        Student student2 = new Student("student2", 24, 69.9f);
        Student student3 = new Student("student3", 25, 89.9f);
        System.out.println("输入的是：");
        student1.print();
        student2.print();
        student3.print();
        FileOutputStream fos = new FileOutputStream("student.txt");
        // FileOutputStream fos = new FileOutputStream("F:/student.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(student1);
        oos.writeObject(student2);
        oos.writeObject(student3);
        oos.close();
        FileInputStream fis = new FileInputStream("student.txt");
        // FileInputStream fis = new FileInputStream("F:/student.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Student stu1 = (Student) ois.readObject();
        Student stu2 = (Student) ois.readObject();
        Student stu3 = (Student) ois.readObject();
        System.out.println("输出的是：");
        stu1.print();
        stu2.print();
        stu3.print();
        ois.close();
    }
}
class Student implements Serializable {
    private String name;
    private int age;
    private float score;
    public Student(String name, int age, float score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public void print() {
        System.out.println("name=" + name + ";age=" + age + ";score=" + score);
    }
}

java中为什么要进行对象序列化？

对象的序列化就是为了数据传输，在你的代码的里是对象格式，而在传输的时候不可能还保持这对象的样子。 当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为java对象。

1. 概念

  • 序列化：把java对象转换为字节序列的过程。
  • 反序列化：把字节序列恢复为java对象的过程。

2. 用途

对象的序列化主要有两种用途：

  1. 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
  2. 在网络上传送对象的字节序列。

Java中对象序列化的作用是什么？全面一点，谢谢

1、序列化是干什么的？

简单说就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存Object States，但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。

2、什么情况下需要序列化

a）当你想把的内存中的对象保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；

3、当对一个对象实现序列化时，究竟发生了什么？

在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance variable）比如：

Foo myFoo = new Foo();
myFoo.setWidth(37);
myFoo.setHeight(70);

当通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（37，70）都被保存到foo.ser文件中，这样以后又可以把它从文件中读出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对象。

FileOutputStream fs = new FileOutputStream("foo.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(myFoo);

4、实现序列化（保存到一个文件）的步骤

a）Make a FileOutputStream

FileOutputStream fs = new FileOutputStream("foo.ser");

b）Make a ObjectOutputStream

ObjectOutputStream os = new ObjectOutputStream(fs);

c）write the object

os.writeObject(myObject1);
os.writeObject(myObject2);
os.writeObject(myObject3);

d）close the ObjectOutputStream

os.close();

5、举例说明

import java.io.*;
public class Box implements Serializable {
    private int width;
    private int height;
    public void setWidth(int width){
        this.width = width;
    }
    public void setHeight(int height){
        this.height = height;
    }
    public static void main(String[] args){
        Box myBox = new Box();
        myBox.setWidth(50);
        myBox.setHeight(30);
        try{
            FileOutputStream fs = new FileOutputStream("foo.ser");
            ObjectOutputStream os = new ObjectOutputStream(fs);
            os.writeObject(myBox);
            os.close();
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }
}

6、相关注意事项

a）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
b）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
c）并非所有的对象都可以序列化，至于为什么不可以，有很多原因了,比如：

  1. 安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
  2. 资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现。

为什么JAVA对象需要实现序列化

序列化是一种用来处理对象流的机制。所谓对象流就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现

将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

什么时候使用序列化

一：对象序列化可以实现分布式对象。主要应用例如：RMI(即远程调用Remote Method Invocation)要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。 二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的"深复制"，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。 三：序列化可以将内存中的类写入文件或数据库中。比如将某个类序列化后存为文件，下次读取时只需将文件中的数据反序列化就可以将原先的类还原到内存中。也可以将类序列化为流数据进行传输。总的来说就是将一个已经实例化的类转成文件存储，下次需要实例化的时候只要反序列化即可将类实例化到内存中并保留序列化时类中的所有变量和状态。 四：对象、文件、数据，有许多不同的格式，很难统一传输和保存。序列化以后就都是字节流了，无论原来是什么东西，都能变成一样的东西，就可以进行通用的格式传输或保存，传输结束以后，要再次使用，就进行反序列化还原，这样对象还是对象，文件还是文件。 因为JAVA中要将对象序列化为流的形式进行传输。

推荐文章