对象的序列化

最新推荐文章于 2024-06-12 11:20:56 发布
最新推荐文章于 2024-06-12 11:20:56 发布
阅读量275 收藏
点赞数
分类专栏： java java语法基础 文章标签： java c++ jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54397364/article/details/128586493
版权

对象流只有字节流，没有字符流

 

 

对象流：ObjectInputStream & ObjectOutputStream
1、对象的序列化：将内存中的对象永久的以二进制形式保存到磁盘中
2、对象的反序列化：将磁盘中保存的对象读取 

package ObjectStream;

import org.testng.annotations.Test;

import java.io.*;

/*
对象流：ObjectInputStream & ObjectOutputStream
1、对象的序列化：将内存中的对象永久的以二进制形式保存到磁盘中
2、对象的反序列化：将磁盘中保存的对象读取
 */
public class ObjectStream {
    //序列化
    @Test
    public void test1(){
        String str="abcde";
        int num=100;
        boolean b=true;
        ObjectOutputStream oos= null;
        try {
            FileOutputStream fos=new FileOutputStream("./data.dat");
            oos = new ObjectOutputStream(fos);
            oos.writeUTF(str);
            oos.writeInt(num);
            oos.writeBoolean(b);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //反序列化
    @Test
    public void test2(){
        ObjectInputStream ois= null;
        try {
            //1、创建FileInputStream的实例，同时打开指定文件
            FileInputStream fis=new FileInputStream("./data.dat");
            //2、创建BufferedInputStream的实例，包装对应节点流，用于提高效率
            BufferedInputStream bis=new BufferedInputStream(fis);
            //3、创建ObjectInputStream 的实例，包装对应的缓冲流，用于完成反序列化
            ois = new ObjectInputStream(bis);
            //4、读取指定文件的内容（按什么顺序序列化的就按什么顺序反序列化）
            String str = ois.readUTF();
            int num = ois.readInt();
            boolean b = ois.readBoolean();
            System.out.println(str+num+b);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5、关闭流
           if (ois!=null){
               try {
                   ois.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
        }
    }
}

 

 

package ObjectStream;

import org.testng.annotations.Test;

import java.io.*;

/*
对象流：ObjectInputStream & ObjectOutputStream
1、对象的序列化：将内存中的对象永久的以二进制形式保存到磁盘中
2、对象的反序列化：将磁盘中保存的对象读取
 */
public class ObjectStream {
   

    //对象的序列化
    @Test
    public void test3(){
        ObjectOutputStream oos= null;
        try {
            Person p1=new Person("张三",18);
            Person p2=new Person("李四",23);
            Person p3=new Person("王五",33);
            FileOutputStream fis=new FileOutputStream("./persons.dat");
            BufferedOutputStream bos=new BufferedOutputStream(fis);
            oos = new ObjectOutputStream(bos);
            oos.writeObject(p1);
            oos.writeObject(p2);
            oos.writeObject(p3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package ObjectStream;

public class Person {
        private String name;
        private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

 

实现Serializable接口的类才能被序列化

package ObjectStream;

import java.io.Serializable;

public class Person implements Serializable {
        private String name;
        private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

 

package ObjectStream;

import org.testng.annotations.Test;

import java.io.*;

/*
对象流：ObjectInputStream & ObjectOutputStream
1、对象的序列化：将内存中的对象永久的以二进制形式保存到磁盘中
2、对象的反序列化：将磁盘中保存的对象读取
 */
public class ObjectStream {
    

    //对象的序列化
    @Test
    public void test3(){
        ObjectOutputStream oos= null;
        try {
            Person p1=new Person("张三",18);
            Person p2=new Person("李四",23);
            Person p3=new Person("王五",33);
            FileOutputStream fis=new FileOutputStream("./persons.dat");
            BufferedOutputStream bos=new BufferedOutputStream(fis);
            oos = new ObjectOutputStream(bos);
            oos.writeObject(p1);
            oos.writeObject(p2);
            oos.writeObject(p3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //对象的反序列化
    @Test
    public void test4(){
        ObjectInputStream ois= null;
        try {
            FileInputStream fis=new FileInputStream("./persons.dat");
            BufferedInputStream bis=new BufferedInputStream(fis);
            ois = new ObjectInputStream(bis);
            Person p1 =(Person)ois.readObject();
            Person p2 =(Person)ois.readObject();
            Person p3 =(Person)ois.readObject();
            System.out.println(p1);
            System.out.println(p2);
            System.out.println(p3);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

对象序列化步骤：

①创建节点流对象
②（可选）创建缓冲流包装对应节点流，用于提高效率
③创建对象流包装对应的缓冲流，用于完成序列化
④通过writeXxx()方法完成序列化
⑤需要序列化对象的类必须实现java.io.Serializable接口

反序列化同上

属性也需要实现接口  

 string实现了接口

 

 

 

一般实现接口后提供一个序列号，方便反序列化

自动生成：

 

 

 

 

使用transient修饰的属性不会被序列化

 

static修饰的属性不会被序列化

 

 

对象流：ObjectInputStream & ObjectOutputStream
1、对象的序列化：将内存中的对象永久的以二进制形式保存到磁盘中

①创建节点流对象
②（可选）创建缓冲流包装对应节点流，用于提高效率
③创建对象流包装对应的缓冲流，用于完成序列化
④通过writeXxx()方法完成序列化
⑤需要序列化对象的类必须实现java.io.Serializable接口
⑥提供序列号private static final Long SerialVersionUID=(long型的id)L;

2、对象的反序列化：将磁盘中保存的对象读取

注意：
    ①transient修饰的属性不会被序列化
    ②static修饰的属性也不会被序列化

 

package ObjectStream;

import org.testng.annotations.Test;

import java.io.*;

/*
对象流：ObjectInputStream & ObjectOutputStream
1、对象的序列化：将内存中的对象永久的以二进制形式保存到磁盘中

①创建节点流对象
②（可选）创建缓冲流包装对应节点流，用于提高效率
③创建对象流包装对应的缓冲流，用于完成序列化
④通过writeXxx()方法完成序列化
⑤需要序列化对象的类必须实现java.io.Serializable接口
⑥提供序列号private static final Long SerialVersionUID=(long型的id)L;

2、对象的反序列化：将磁盘中保存的对象读取

注意：
    ①transient修饰的属性不会被序列化
    ②static修饰的属性也不会被序列化
 */
public class ObjectStream {
    //序列化
    @Test
    public void test1(){
        String str="abcde";
        int num=100;
        boolean b=true;
        ObjectOutputStream oos= null;
        try {
            FileOutputStream fos=new FileOutputStream("./data.dat");
            oos = new ObjectOutputStream(fos);
            oos.writeUTF(str);
            oos.writeInt(num);
            oos.writeBoolean(b);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //反序列化
    @Test
    public void test2(){
        ObjectInputStream ois= null;
        try {
            //1、创建FileInputStream的实例，同时打开指定文件
            FileInputStream fis=new FileInputStream("./data.dat");
            //2、创建BufferedInputStream的实例，包装对应节点流，用于提高效率
            BufferedInputStream bis=new BufferedInputStream(fis);
            //3、创建ObjectInputStream 的实例，包装对应的缓冲流，用于完成反序列化
            ois = new ObjectInputStream(bis);
            //4、读取指定文件的内容（按什么顺序序列化的就按什么顺序反序列化）
            String str = ois.readUTF();
            int num = ois.readInt();
            boolean b = ois.readBoolean();
            System.out.println(str+num+b);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5、关闭流
           if (ois!=null){
               try {
                   ois.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
        }
    }

    //对象的序列化
    @Test
    public void test3(){
        ObjectOutputStream oos= null;
        try {
            Person p1=new Person("张三",18);
            Person p2=new Person("李四",23);
            Person p3=new Person("王五",33);
            FileOutputStream fis=new FileOutputStream("./persons.dat");
            BufferedOutputStream bos=new BufferedOutputStream(fis);
            oos = new ObjectOutputStream(bos);
            oos.writeObject(p1);
            oos.writeObject(p2);
            oos.writeObject(p3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //对象的反序列化
    @Test
    public void test4(){
        ObjectInputStream ois= null;
        try {
            FileInputStream fis=new FileInputStream("./persons.dat");
            BufferedInputStream bis=new BufferedInputStream(fis);
            ois = new ObjectInputStream(bis);
            Person p1 =(Person)ois.readObject();
            Person p2 =(Person)ois.readObject();
            Person p3 =(Person)ois.readObject();
            System.out.println(p1);
            System.out.println(p2);
            System.out.println(p3);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

Mr.易湿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
两种对象序列化方式
茅屋
11-16 1813
用途：android中经常通过intent传值时需要传入一个对象，而intent.putExtra()中并没有对应的方法，所以我们需要实现对象的序列化进行传值   1，实现Serializable   直接让对象实现Serializable方法即可。
Java对象序列化（整理篇）
风帆的Blog
07-21 2590
      在网上看了很多有关序列化的文章，我自己也写了两篇，现在感觉这些文章都没有很好的把序列化说清楚(包括我自己在内)，所以在此我将总结前人以及自己的经验，用更浅显易懂的语言来描述该机制，当然，仍然会有不好的地方，希望你看后可以指出，作为一名程序员应该具有不断探索的精神和强烈的求知欲望！ 序列化概述：       简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化
Java对象序列化和反序列化的基本方法及应用场景
最新发布
Itmastergo的博客
06-12 1563
序列化（Serialization）是将对象的状态转换为字节流的过程，这样它们就可以通过网络传输或存储到文件系统中。反序列化（Deserialization）则是将字节流转换回对象的过程，恢复原有的状态。远程通信：例如RMI（Remote Method Invocation）和RPC（Remote Procedure Call）中，需要将对象从一台机器传输到另一台机器。缓存：对象可以被序列化并存储到缓存中，以便后续快速读取。持久化：将对象存储到文件或数据库中，以便后续恢复。深拷贝。
完整的Java序列化方式
GM_115的博客
12-23 391
Java序列化 Java提供了一种对象序列化机制，可以将对象表示为一个字节序列，该字节序列包括对象的数据、对象的类型信息，和对象中数据的类型，将序列化的对象保存在文件中，然后在文件中读取序列，然后反序列化。 类 ObjectInputStream 和 ObjectOutputStream 是高层次的数据流，它们包含反序列化和序列化对象的方法。 public final void write...
对象序列化
tianhumanong的博客
04-23 4844
1.对象序列化的作用 1、Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能 2、使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的"状态"，即它的成员变量。由
Java中对象序列化与反序列化详解
09-03
在Java编程中，对象序列化是一个重要的概念，它允许将Java对象转换为字节序列，便于存储或在网络中传输。这个过程被称为序列化，而将字节序列恢复为原来的对象则称为反序列化。本文将深入探讨Java中的对象序列化与反...
详解JavaScript对象序列化
10-22
对象序列化是指将一个程序中对象的状态信息转换成可以存储或传输的格式的过程。具体来说，它涉及将对象的属性和值编码为一种形式，通常是字符串或字节流，这样数据就能够在程序运行时之外的环境中持久化或传输。当...
JavaScript中的对象序列化介绍
10-24
主要介绍了JavaScript中的对象序列化介绍,JavaScript中的对象序列化是通过JSON.stringify()来实现的,而反序列化则通过JSON.parse()来实现,需要的朋友可以参考下
Java对象序列化操作详解
08-27
Java 对象序列化操作详解 Java 对象序列化是 Java 语言中一种重要的机制，它允许将 Java 对象转换为字节序列，以便在网络上传送或保存到文件中。对象序列化操作主要有两种用途：把对象的字节序列永久地保存到硬盘上...
Java 中如何序列化一个对象
selfimpr
09-13 2054
我们都知道java 中无法保存一个对象到文本文件中，但是当我们有这种需求的时候，我们可以通过java 的序列化功能把当前对象的一些属性以二进制的形式保存到文件中。当我们需要这个对象的时，只需要从二进制文件中还原为保存前的对象即可。从这里我们可以得到启发，如果想把机器A 上的一个Student 对象发送到机器B上，我们可以把Student 对象序列化成二进制，然后把该二进制发送给机器B ，机器B 就
"对象的序列化"简介
yuyu`s Blog
09-28 1744
    所谓对象序列化就是将对象的状态转换成字节流，以后可以通过这些值再生成相同状态的对象。这个过程也可以通过网络实现，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。是不是很神奇。    也许你会说，只了解一点点，但从来没有接触过，其实未必如此。RMI、Socket、JMS、EJB你总该用过一种吧，彼此为什么能够传递Jav
怎么序列化对象
u011644138的博客
02-19 1749
[Serializable] 序列化对象的类添加这个表示 [SerializeField]序列化对象的字段要添加这个标识，否则需要在构造函数里赋值 如果想unity 的 ScriptableObject 实时保存的工具只能放置一维数组，看情况用，能同时使用。不是很建议使用 如果做好了上边内容 使用如下 //参考 void SAVE() { if (!Directory.Exists(Application.dataPath + "/Map..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值