精华内容
下载资源
问答
  • package ... import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutpu...
    package com.oracle.core;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Person implements Serializable
    {
    
    	private int pid;
    	private String pname;
    	private char sex;
    	
    	
    	public Person()
    	{
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    
    	public Person(int pid, String pname, char sex)
    	{
    		super();
    		this.pid = pid;
    		this.pname = pname;
    		this.sex = sex;
    	}
    
    
    	@Override
    	public String toString()
    	{
    		// TODO Auto-generated method stub
    		return "Person [pid=" + pid + ", pname=" + pname + ", sex=" + sex + "]";
    	}
    
    
    	public static void main(String[] args) throws IOException, ClassNotFoundException
    	{
    		//把对象的原始信息和图形保存到文件中 序列化
    		Person p=new Person(1,"小红",'女');
    		ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(new File("D:\\p.txt")));
    		out.writeObject(p);
    		//拿出来
    		ObjectInputStream in=new ObjectInputStream(new FileInputStream(new File("D:\\p.txt")));
    		Object readObject = in.readObject();
    		System.out.println(readObject);
    		
    	}
    
    
    	
    }
    
    

    得到了这个对象的原始信息:
    在这里插入图片描述

    展开全文
  • java对象流(序列化与反序列化)

    千次阅读 2017-06-27 13:57:22
    1.序列化和反序列化 序 列 化:指把堆内存中的Java对象数据,...反序列化:把磁盘文件中的对象数据或者把网络节点上的对象数据,恢复成Java对象的过程. 为什么要做序列化:  1):在分布式系统中,需要共享的数据的JavaB

    1.序列化和反序列化

    序  列 化:指把堆内存中的Java对象数据,通过某种方式把对象存储到磁盘文件中或者传递给其他网络的节点(在网络上传输).
                   我们把这个过程称之为序列化.
    反序列化:把磁盘文件中的对象数据或者把网络节点上的对象数据,恢复成Java对象的过程.
    为什么要做序列化:
                  1):在分布式系统中,需要共享的数据的JavaBean对象,都得做序列化,此时需要把对象再网络上传输,此时就得把对象数据转换为二进制形式.以后存储在HttpSession中的对象,都应该实现序列化接口(只有实现序列化接口的类,才能做序列化操作).

                  2):服务钝化:如果服务发现某些对象好久都没有活动了,此时服务器就会把这些内存中的对象,持久化在本地磁盘文件中(Java对象-->二进制文件).如果某些对象需要活动的时候,现在内存中去寻找,找到就使用,找不到再去磁盘文件中,反序列化我们得对象数据,恢复成Java对象.

    需要做序列化的对象的类,必须实现序列化接口:java.io.Serializable接口(标志接口[没有抽象方法]).底层会判断,如果当前对象是Serializable的实例,才允许做序列化.    boolean   ret = Java对象  instanceof  Serializable;

        在Java中大多数类都已经实现Serializable接口.

    2.使用对象流来完成序列化和反序列化操作

         ObjectOutputStream:  通过writeObject方法做序列化操作的.
         ObjectInputStream:     通过readObject方法做反序列化操作的. 
       做反序列化操作必须存在对象的字节码对象.

    下面我们来对一个User对象做序列化和反序列化

    首先创建一个User对象,就是我们平时使用的javaBean

    
    public class User{
    	private int id;
    	private String nameString;
    	private int age;
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getNameString() {
    		return nameString;
    	}
    	public void setNameString(String nameString) {
    		this.nameString = nameString;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public User(int id, String nameString, int age) {
    		super();
    		this.id = id;
    		this.nameString = nameString;
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "User [id=" + id + ", nameString=" + nameString + ", age=" + age
    				+ "]";
    	}
    }
    测试:

    import java.io.FileOutputStream;
    import java.io.ObjectOutputStream;
    
    public class IODemo7 {
    	public static void main(String[] args) throws Exception {
    		writeObject();
    	}
    	
    	//使用对象流对User对象进行序列化操作
    	private static void writeObject() throws Exception {
    		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("user.txt"));
    		out.writeObject(new User(1,"张三",18));
    		out.close();
    	}
    }
    此时会以下报错,为什么?这是因为我们自己定义的User类还没有实现序列化接口


    这时我们就应该修改User类,让它实现Serializable接口

    import java.io.Serializable;
    
    public class User implements Serializable{
    	private int id;
    	private String nameString;
    	private int age;
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getNameString() {
    		return nameString;
    	}
    	public void setNameString(String nameString) {
    		this.nameString = nameString;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public User(int id, String nameString, int age) {
    		super();
    		this.id = id;
    		this.nameString = nameString;
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "User [id=" + id + ", nameString=" + nameString + ", age=" + age
    				+ "]";
    	}
    }

    这时运行就能成功将User对象写入到文件中,然后我们打开肯定看不懂的,需要对象流输入流来进行反序列化操作


    下面我们进行反序列化

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class IODemo7 {
    	public static void main(String[] args) throws Exception {
    		writeObject();//序列化
    		readObject();//反序列化
    	}
    	//使用对象流对User对象进行序列化操作
    	private static void writeObject() throws Exception {
    		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("user.txt"));
    		out.writeObject(new User(1,"张三",18));
    		out.close();
    	}
    	//使用对象流对User对象进行反序列化操作
    	private static void readObject() throws Exception {
    		ObjectInputStream in = new ObjectInputStream(new FileInputStream("user.txt"));
    		User user = (User)in.readObject();
    		System.out.println(user);//User [id=1, nameString=张三, age=18]
    	}
    }
    打印结果: User [id=1, nameString=张三, age=18]

    3.序列化的细节序列化的版本

        1):如果某些数据不需要做序列化,比如密码,此时怎么办?
              理论上说,静态的字段和瞬态的字段是不能做序列化操作的.

    下面我们的User类添加一个password字段,然后在字段前面加上一个修饰符transient,看代码

    import java.io.Serializable;
    
    public class User implements Serializable{
    	private int id;
    	transient private int password;//加上了transient修饰符
    	private String nameString;
    	private int age;
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public void setPassword(int password) {
    		this.password = password;
    	}
    	public int getPassword() {
    		return password;
    	}
    	public String getNameString() {
    		return nameString;
    	}
    	public void setNameString(String nameString) {
    		this.nameString = nameString;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public User(int id, int password, String nameString, int age) {
    		super();
    		this.id = id;
    		this.password = password;
    		this.nameString = nameString;
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "User [id=" + id + ", password=" + password + ", nameString="
    				+ nameString + ", age=" + age + "]";
    	}
    }
    这时候的password就不会被序列化



        2):序列化的版本问题:
            反序列化Java对象时必须提供该对象的class文件,现在问题是,随着项目的升级,系统的class文件也会升级(增加一个字段/删除一个字段),如何保证两个class文件的兼容性? Java通过serialVersionUID(序列化版本号)来判断字节码是否发生改变.如果不显示定义serialVersionUID类变量,该类变量的值由JVM根据类相关信息计算,而修改后的类的计算方式和之前往往不同.从而造成了对象反序列化因为版本不兼容而失败的问题.







    此时我们需要给我们的User加上一个序列化ID就可以了


    那么以后我们无论添加或者修改字段之后都不会在报错,要保证序列化ID相同


    总结:其实在开发中,我们只需要对我们自己定义的类加上序列化ID就行了,至于序列化和反序列化这个对象,框架会帮我们完成!!!

    展开全文
  • 主要介绍了Java IO流对象序列化和反序列化实例详解的相关资料,需要的朋友可以参考下
  • 在java.beans包中,有两个好东西,XMLEncoder和XMLDecoder。从XML存取对象真是太费力气啦。做了小工具类,以后可以用用了。本文介绍了这两个可以把JAVA对象序列化保存为XML文件的工具类。
  • 主要介绍了java IO数据操作对象序列化、压缩代码解析,具有一定借鉴价值,需要的朋友可以参考下
  •  Java中的序列化(serialization)机制能够将一个实例对象的状态信息写入到一个字节中,使其可以通过socket进行传输、或者持久化存储到数据库或文件系统中;然后在需要的时候,可以根据字节中的信息来重构一个...
  • 对象序列化:就是将对象保存到磁盘中,或者在网络中传输对象 这种机制就是使用一个字节序列表示一个对象,该字节序列包含:对象的类型、对象的数据和对象中存储的属性等信息 ...对象序列化流:ObjectOu.

    这个连接包含了常用的流------IO流(总篇章)  

    对象序列化:就是将对象保存到磁盘中,或者在网络中传输对象

    这种机制就是使用一个字节序列表示一个对象,该字节序列包含:对象的类型、对象的数据和对象中存储的属性等信息

    字节序列写到文件后,相当于文件中持久保存了一个对昂的信息

    反之。该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化

    要实现序列化与反序列化,就要使用对象序列化流和对象反序列化流:

    • 对象序列化流:ObjectOutputStream
    • 对象反序列化流:ObjectInputStream

    对象序列化流:ObjectOutputStream

    • 将Java对象的原始数据类型和图像写入OutputStream。可以使用ObjectInputStream读取(重构)对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流,则可以再另外一个主机上或另一个进程中重构对象
    • 构造方法:ObjectOutputStream(OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
    • 序列化对象的方法:void writeObject(Object obj):将指定的对象写入ObjectOutputStream

    下面我们放代码演示

    学生类

    package com.testIO;
    
    /**
     * @author 林高禄
     * @create 2020-05-12-21:39
     */
    public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            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;
        }
    }
    

    序列化Demo

    package com.testIO;
    
    import java.io.*;
    
    /**
     * @author 林高禄
     * @create 2020-05-10-13:11
     */
    public class ObjectOutputStreamDemo {
        public static void main(String[] args) throws IOException{
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test//src//com//testIO//oos.txt"));
            Student s = new Student("林高禄",27);
            oos.writeObject(s);
            oos.close();
        }
    }
    

    运行出现以下错误:

    Exception in thread "main" java.io.NotSerializableException: com.testIO.Student
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
        at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
        at com.testIO.ObjectOutputStreamDemo.main(ObjectOutputStreamDemo.java:13)

    NotSerializableException

    抛出一个实例需要Serializable接口。序列化运行时或实例的类可能会抛出此异常

    Serializable

    类的序列化由实现java.io.Serializable接口的类启用。不实现此接口的类将不会使任何状态序列化或反序列化。可序列化类的所有子类型都是可序列化的。序列化接口没有方法或字段,仅用于标识可串行化的语义。

    到这里我们就明白报 java.io.NotSerializableException: com.testIO.Student异常的原因是,学生类Student没有实现Serializable接口,下面我们把Student代码修改一下,去实现Serializable接口。

    package com.testIO;
    
    import java.io.Serializable;
    
    /**
     * @author 林高禄
     * @create 2020-05-12-21:39
     */
    public class Student implements Serializable {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            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;
        }
    }
    

    再次运行,得到oos.txt文件含有一下内容

     到这里,说明我们的序列化成功

    注意:

    • 一个对象要想被序列化,该对象所属的类必须实现Serializable接口。
    • Serializable是一个标记接口,实现该接口,不需要重写任何方法。

    对象反序列化流:ObjectInputStream

    • ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象
    • 构造方法:ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream
    • 反序列化对象的方法:Object readObject():从ObjectInputStream读取一个对象
    package com.testIO;
    
    import java.io.*;
    
    /**
     * @author 林高禄
     * @create 2020-05-10-13:11
     */
    public class ObjectInputStreamDemo {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test//src//com//testIO//oos.txt"));
            Object obj = ois.readObject();
            Student s = (Student)obj;
            System.out.println(s.getName()+","+s.getAge());
            ois.close();
        }
    }
    

    输出:

    林高禄,27

    到这里,说明我们的反序列化成功

    下面我们做一下骚修改,反序列化之前,我们对Student类做了些修改,比如重写了toString()方法

    package com.testIO;
    
    import java.io.Serializable;
    
    /**
     * @author 林高禄
     * @create 2020-05-12-21:39
     */
    public class Student implements Serializable {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            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 "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    再执行一次反序列化Demo,控制台报以下异常

    Exception in thread "main" java.io.InvalidClassException: com.testIO.Student; local class incompatible: stream classdesc serialVersionUID = 5613672065288821876, local class serialVersionUID = 7003572463648716337
        at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:621)
        at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1623)
        at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)
        at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)
        at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
        at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
        at com.testIO.ObjectInputStreamDemo.main(ObjectInputStreamDemo.java:12)

    InvalidClassException:

    当序列化运行时检测到类中的以下问题之一时抛出

    • 类的串行版本与从流中读取的类描述符的类型不匹配
    • 该类包含未知的数据类型
    • 该类没有可访问的无惨构造函数

    stream classdesc serialVersionUID = 5613672065288821876, local class serialVersionUID = 7003572463648716337

    从这里我们知道,我们序列化是学生类的serialVersionUID = 5613672065288821876,而修改类后,local class serialVersionUID = 7003572463648716337,所以反序列异常

    serialVersionUID

    序列化运行时与每个可序列化的类关联一个版本号,称为serialVersionUID,它在反序列化的过程中使用,以验证序列化对象的发送者和接收者是否加载了与序列化兼容的对象的类。如果接收者已经具有与对应发件人类别不用的serialVersionUID的对象加载了一个类,则反序列化将导致一个InvalidClassException。一个可序列化的类可以通过声明一个名为“serialVersionUID”的字段来显式地声明它自己的serialVersionUID,该字段必须是staticfinal,和long类型。

    知道原因之后,我们又修改了学生类,声明serialVersionUID

    package com.testIO;
    
    import java.io.Serializable;
    
    /**
     * @author 林高禄
     * @create 2020-05-12-21:39
     */
    public class Student implements Serializable {
        private static final long serialVersionUID = 22L;
        private String name;
        private int age;
        private transient int bb;
    
        public Student() {
        }
    
        public Student(String name, int age, int bb) {
            this.name = name;
            this.age = age;
            this.bb = bb;
        }
    
        public static Long getSerialVersionUID() {
            return serialVersionUID;
        }
    
        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 int getBb() {
            return bb;
        }
    
        public void setBb(int bb) {
            this.bb = bb;
        }
    }
    
    package com.testIO;
    
    import java.io.*;
    
    /**
     * @author 林高禄
     * @create 2020-05-10-13:11
     */
    public class ObjectOutputStreamDemo {
        public static void main(String[] args) throws IOException{
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test//src//com//testIO//oos.txt"));
            Student s = new Student("林高禄",27,55);
            oos.writeObject(s);
            oos.close();
        }
    }
    

     

    执行序列化Demo之后,在修改Student类的代码,比如重写toString()方法,再执行反序列化Demo

     

    package com.testIO;
    
    import java.io.Serializable;
    
    /**
     * @author 林高禄
     * @create 2020-05-12-21:39
     */
    public class Student implements Serializable {
        private static final long serialVersionUID = 22L;
        private String name;
        private int age;
        private transient int bb;
    
        public Student() {
        }
    
        public Student(String name, int age, int bb) {
            this.name = name;
            this.age = age;
            this.bb = bb;
        }
    
        public static Long getSerialVersionUID() {
            return serialVersionUID;
        }
    
        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 int getBb() {
            return bb;
        }
    
        public void setBb(int bb) {
            this.bb = bb;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", bb=" + bb +
                    '}';
        }
    }
    
    package com.testIO;
    
    import java.io.*;
    
    /**
     * @author 林高禄
     * @create 2020-05-10-13:11
     */
    public class ObjectInputStreamDemo {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test//src//com//testIO//oos.txt"));
            Object obj = ois.readObject();
            Student s = (Student)obj;
            System.out.println(s.getName()+","+s.getAge()+","+s.getBb());
            ois.close();
        }
    }
    

    输出:

    林高禄,27,0

    反序列化成功,但是我们发现bb=0,这是为什么呢,注意看学生类属性bb的定义, private transient int bb,关键字transient 作用就是使得修饰的属性不被序列化,所以反序列得出来的值是默认值0。

    展开全文
  • 主要介绍了java序列化与ObjectOutputStream和ObjectInputStream的实例详解的相关资料,希望通过本文能帮助到大家,需要的朋友可以参考下
  • 说到Java对象序列化与反序列化,我们首先想到的应该是Java的Serializable接口,这玩意在两个系统之间的DTO对象里面可能会用到,用于系统之间的数据传输。或者在RPC(远程方法调用)时可能会用到。 本文要说的是...

    前言:
    说到Java对象的序列化与反序列化,我们首先想到的应该是Java的Serializable接口,这玩意在两个系统之间的DTO对象里面可能会用到,用于系统之间的数据传输。或者在RPC(远程方法调用)时可能会用到。

    本文要说的是Java对象与Json的相互转换。目前Java常用的Json类库有3种,即fastjson、jackson和gson,分别介绍如何将一个Java对象转换成Json和将一个Json字符串转换成Java对象,其实它们的用法大同小异。

    • 一、首先看Maven依赖
    • 二、需要序列化的POJO和初始化代码
    • 三、fastjson的使用
    • 四、jackson的使用
    • 五、gson的使用

    一、首先看Maven依赖

    若不会maven,请参考Maven的基本用法:http://jisonami.iteye.com/blog/2300036

    <!-- json -->  
    <!-- 引入fastjson依赖 -->  
    <dependency>  
        <groupId>com.alibaba</groupId>  
        <artifactId>fastjson</artifactId>  
        <version>1.2.12</version>  
    </dependency>  
    <!-- 引jackson依赖 -->  
    <!-- jackson核心包,必选,提供基于“流模式”解析的API -->  
    <dependency>  
        <groupId>com.fasterxml.jackson.core</groupId>  
        <artifactId>jackson-core</artifactId>  
        <version>2.7.4</version>  
    </dependency>  
    <!-- jackson注解包,可选,提供注解功能 -->  
    <dependency>  
        <groupId>com.fasterxml.jackson.core</groupId>  
        <artifactId>jackson-annotations</artifactId>  
        <version>2.7.4</version>  
    </dependency>  
    <!-- jackson数据绑定包,可选,提供基于“对象绑定”和“树模型”相关API -->  
    <dependency>  
        <groupId>com.fasterxml.jackson.core</groupId>  
        <artifactId>jackson-databind</artifactId>  
        <version>2.7.4</version>  
    </dependency>  
    <!-- 引入gson依赖 -->  
    <dependency>  
        <groupId>com.google.code.gson</groupId>  
        <artifactId>gson</artifactId>  
        <version>2.6.2</version>  
    </dependency>
    

    二、需要序列化的POJO和初始化代码
    以下3种类库的使用均使用下面这个POJO

    public class User {  
        public User(){}  
        private String id;  
        private String name;  
        private String password;  
        public String getId() {  
            return id;  
        }  
        public void setId(String id) {  
            this.id = id;  
        }  
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
        public String getPassword() {  
            return password;  
        }  
        public void setPassword(String password) {  
            this.password = password;  
        }  
        @Override  
        public String toString() {  
            return "User [id=" + id + ", name=" + name + ", password=" + password  
                    + "]";  
        }     
    }
    
    /** 
     - 初始化User对象 
     - @return user 
     */  
    private static User initUser(){  
        User user = new User();  
        user.setId("1");  
        user.setName("jison");  
        user.setPassword("jison");  
        return user;  
    }
    

    三、fastjson的使用
    Fast的常用方法:

    • put(String key, Object value)方法,在JSONObject对象中设置键值对在,在进行设值得时候,key是唯一的,如果用相同的key不断设值得时候,保留后面的值。
    • Object get(String key) :根据key值获取JSONObject对象中对应的value值,获取到的值是Object类型,需要手动转化为需要的数据类型
    • int size():获取JSONObject对象中键值对的数量
    • boolean isEmpty():判断该JSONObject对象是否为空
    • containsKey(Object key):判断是否有需要的key值
    • boolean containsValue(Object value):判断是否有需要的value值
    • JSONObject getJSONObject(String key):如果JSONObjct对象中的value是一个JSONObject对象,即根据key获取对应的JSONObject对象;
    • JSONArray getJSONArray(String key) :如果JSONObject对象中的value是一个JSONObject数组,既根据key获取对应的JSONObject数组;
    • Object remove(Object key):根据key清除某一个键值对。由于JSONObject是一个map,它还具有map特有的两个方法:
    • Set keySet() :获取JSONObject中的key,并将其放入Set集合中
    • Set<Map.Entry<String, Object>> entrySet():在循环遍历时使用,取得是键和值的映射关系,Entry就是Map接口中的内部接口与String字符串转换:
    • toJSONString() /toString():将JSONObject对象转换为json的字符串

    fastjson的主要工具类是JSON,以下代码实现Java对象的序列化与反序列化

     // 将Java对象序列化为Json字符串  
       String objectToJson = JSON.toJSONString(initUser());  
         System.out.println(objectToJson);  
         // 将Json字符串反序列化为Java对象  
         User user = JSON.parseObject(objectToJson, User.class);  
        System.out.println(user);  
    

    四、jackson的使用
    jackson我们经常用到的是它的数据绑定包下的ObjectMapper类,以下代码实现Java对象的序列化与反序列化

    ObjectMapper objectMapper = new ObjectMapper();  
        // 将Java对象序列化为Json字符串  
        String objectToJson = objectMapper.writeValueAsString(initUser());  
        System.out.println(objectToJson);  
        // 将Json字符串反序列化为Java对象  
        User user = objectMapper.readValue(objectToJson, User.class);  
        System.out.println(user);
    

    五、gson的使用
    gson的主要工具类是Gson,使用GsonBuilder构造,以下代码实现Java对象的序列化与反序列化

    Gson gson = new GsonBuilder().create();  
        // 将Java对象序列化为Json字符串  
        String objectToJson = gson.toJson(initUser());  
        System.out.println(objectToJson);  
        // 将Json字符串反序列化为Java对象  
        User user = gson.fromJson(objectToJson, User.class);  
        System.out.println(user);
    

    以上3种json类库的完整代码如下:

    public class JsonUtils {  
      
        /** 
         * 初始化User对象 
         * @return user 
         */  
        private static User initUser(){  
            User user = new User();  
            user.setId("1");  
            user.setName("jison");  
            user.setPassword("jison");  
            return user;  
        }  
          
        public static void main(String[] args) throws Exception {  
            // fastjson用法  
            fastjson();  
            // jackson用法  
            jackson();  
            // gson用法  
            gson();  
        }  
          
        private static void fastjson(){  
            // 将Java对象序列化为Json字符串  
            String objectToJson = JSON.toJSONString(initUser());  
            System.out.println(objectToJson);  
            // 将Json字符串反序列化为Java对象  
            User user = JSON.parseObject(objectToJson, User.class);  
            System.out.println(user);  
        }  
          
        private static void jackson() throws Exception{  
            ObjectMapper objectMapper = new ObjectMapper();  
            // 将Java对象序列化为Json字符串  
            String objectToJson = objectMapper.writeValueAsString(initUser());  
            System.out.println(objectToJson);  
            // 将Json字符串反序列化为Java对象  
            User user = objectMapper.readValue(objectToJson, User.class);  
            System.out.println(user);  
        }  
          
        private static void gson(){  
            Gson gson = new GsonBuilder().create();  
            // 将Java对象序列化为Json字符串  
            String objectToJson = gson.toJson(initUser());  
            System.out.println(objectToJson);  
            // 将Json字符串反序列化为Java对象  
            User user = gson.fromJson(objectToJson, User.class);  
            System.out.println(user);  
        }  
    }
    
    展开全文
  • Java对象序列化详解

    万次阅读 多人点赞 2016-08-10 14:47:32
    一、定义 序列化:把Java对象转换为字节序列的过程。    反序列化:把字节序列恢复为Java对象的过程。二、用途 对象的序列化主要有两种用途:    1) 把对象的字节序列永久地保存到硬盘上,通常存放在一...
  • python-javaobj 是一个 python 库,它提供了读取和写入(写入当前是 WIP)Java 对象的函数,序列化或将被ObjectOutputStream反序列化。 这种对象表示形式是 Java 世界中的标准数据交换格式。 javaobj 模块公开了...
  • 在一开始学习java流操作中的有关对象序列化与非序列化的时候,很多初学者会纠结于写出的文件出现乱码的问题。 以下是有关序列化与反序列化的相关代码。 第一步:先创建相关的对象。 package day02; import java....
  • java对象序列化并存储到文件和数据库

    万次阅读 热门讨论 2017-04-25 09:15:45
    Java中要实现将对象保存起来持久化,需要让对象实现Serializable接口,这样就能将java对象用二进制保存并恢复。下面我将以保存到文件和保存到mysql来进行解析。先给出序列化类的定义:package model; import java....
  • 对象序列化和反序列化流
  • Java IO 对象流的使用和序列化的注意点1.ObjectInputStream和OjbectOutputSteam2.对象序列化3. 使用对象流序列化对象4.demo 1.ObjectInputStream和OjbectOutputSteam 用于存储和读取对象的处理。它的...
  • java 序列化追加文件及反序列化读取多个对象

    千次阅读 多人点赞 2018-06-10 11:17:49
    先来看看java的ObjectOutputStream和ObjectInputStream源码好了public ObjectOutputStream(OutputStream out) throws IOException { verifySubclass(); bout = new BlockDataOutputStream(out); ...
  • 所谓对象序列化就是将对象的状态转换成字节,以后可以通过这些值再生成相同状态的对象,下面详细介绍一下java对象的序列化使用方法
  • 序列化(Serializable):序列化就是指把内存中的对象变成二进制的形式进行传输或者保存在文本中。就是我这里写了一个类要发给你,我发给你的不可能直接是这个类,而是这个类经过编码后的字节码。 2.实现 一个类若是...
  • Java对象序列化(Serialization)和反序列化详解

    万次阅读 多人点赞 2018-02-13 15:56:02
    1.序列化和反序列化 序列化(Serialization)是将对象的状态信息转化为可以存储或者传输的形式的过程,一般将一个对象...2.Java对象序列化和反序列化 在Java中,我们可以通过多种方式来创建对象,并且只要对象...
  • Java 序列化与反序列化

    千次阅读 2020-09-05 13:04:20
    介绍 Java序列化与反序列化
  • 如何将一个java对象序列化到文件里?

    千次阅读 2019-03-06 10:56:30
    java中能被序列化的类必须实现Serializable接口,该接口没有任何抽象方法只是起到一个标记作用. ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("D://obj")); ...
  • Java 对象序列化

    千次阅读 多人点赞 2020-02-04 11:03:30
    文章目录什么是序列化?举例:(定义一个可以被序列化的类)序列化与反序列化举例:(实现序列化与反序列化)transient 关键字举例:(transient 关键字的使用...所谓的对象序列化指的是将内存中保存的对象以二进制...
  • JAVA--数据字节,对象流序列化

    千次阅读 2018-09-03 17:46:22
    数据字节 DataOutputStream与DataInputStream 父类与缓冲一样都是过滤字节:FilterOutputStream与FilterInputStream,这两个类可以写基本数据类型. DataOutputStream 这里只写了代码,方法的介绍可以看注释: ...
  • Java对象序列化成字符串和反序列化

    千次阅读 2015-05-24 22:31:41
    1、序列化序列化后保存在一个字符串变量中 package com.lxh.ser.test; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; import java.util.ArrayList; ...
  • Java 对象序列化机制详解

    千次阅读 2014-10-09 22:24:07
    对象序列化机制允许把内存中的Java对象转换成平台无关的二进制,从而允许把这种二进制持久的保存在磁盘上,通过网络将这种二进制传输到另一个网络节点。其他程序一旦获得了这种二进制,都可以讲这种二进制...
  • 通过Java序列化对象存入json文件中

    千次阅读 2019-04-11 17:15:43
    * 实现对象序列化的追加 * @param path * @param user * @throws IOException */ public static void writeObjectJson(String path, UserPojo user) throws IOException { File file = new File(path); // ...
  • 0 前言 全是干货的技术殿堂 文章收录在我的 GitHub 仓库,欢迎Star/fork: ...Java序列化是指把Java对象保存为二进制字节码的过程,Java反序列化是指把二进制码重新转换成Java对象的过程。 那么为什么需要序列...
  • Java序列化实现原理研究

    万次阅读 多人点赞 2018-05-31 17:25:39
    1.什么是序列化和反序列化 序列化 是指将Java对象保存为二进制字节码的过程。 反序列化 将二进制字节码重新转成Java对象的过程。 2.为什么序列化 我们知道,一般Java对象的生命周期比Java...
  • Java序列化和打印

    千次阅读 2019-07-12 14:22:48
    一、对象序列化和反序列化 1、概述 2、对象序列化ObjectOutputStream和反序列化ObjectInputStream 二、序列化注意事项 1、静态不能序列化 2、瞬态 transient 关键字 3、Serializable 接口的含义 4、序列化中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 150,262
精华内容 60,104
关键字:

java对象序列化流

java 订阅