Flexjson或Gson:在对象序列化后保护对象引用

I使用flexjson序列化列表。序列化之后，我打印对象hashcode()，然后检查对象是否相等。

问题是，操作后对象引用正在更改。我不想要。

我的代码；

    String sameOfString="sameOfString";
    List<Object> list=new ArrayList<Object>();
    list.add(sameOfString);
    list.add(sameOfString);
    list.add("differentString");
    for(Object str:list){
        System.out.println(str.hashCode());
    }
    **System.out.println(list.get(0)==list.get(1));**
    System.out.println(list.get(0)==list.get(2));
    System.out.println("--");
    String json= new JSONSerializer().exclude("*.class").deepSerialize(list);
    List<String> listDeserilized = (List<String>) new JSONDeserializer().deserialize(json);
    for(Object str:listDeserilized){
        System.out.println(str.hashCode());
    }
    **System.out.println(listDeserilized.get(0)==listDeserilized.get(1));**
    System.out.println(listDeserilized.get(0)==listDeserilized.get(2));

和输出。。

1018069468
1018069468
199675306
真
错误
-
1018069468
1018069468
199675306
错误
错误

如何解决这个问题？

我用jackson lib解决了我的问题。

@JsonIdentityInfo注释保护对象关系（换句话说，保护引用）在反序列化之后，对象在内存中的位置不会改变。

最终代码：

package com.maar.projectbuilder;
import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
 * Created by Firat on 11.9.2014.
 */
public class Testt {
    @JsonDeserialize(as=StringClazz.class)
    @JsonTypeInfo(use=JsonTypeInfo.Id.CLASS, include=JsonTypeInfo.As.PROPERTY, property="@class")
    @JsonIdentityInfo(generator=ObjectIdGenerators.IntSequenceGenerator.class, property="@id")
    @JsonTypeName(value = "StringClazz")
    private static class StringClazz{
        private String data="";
        public StringClazz() {
        }
        public String getData() {
            return data;
        }
        public void setData(String data) {
            this.data = data;
        }
    }
    public static void main(String[] args) throws IOException {
        StringClazz someOfString=new StringClazz();
        someOfString.setData("someOfString");
        StringClazz differentString=new StringClazz();
        differentString.setData("differentString");
        List<StringClazz> list=new ArrayList<StringClazz>();
        list.add(someOfString);
        list.add(someOfString);
        list.add(differentString);
        for(Object str:list){
            System.out.println(str.hashCode());
        }
        System.out.println(list.get(0)==list.get(1));
        System.out.println(list.get(0)==list.get(2));
        System.out.println("-------");
        String json= null;
        try {
            json = new ObjectMapper().enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL).writeValueAsString(list);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        System.out.println(json);
        List<StringClazz> listDeserilized =new ObjectMapper().enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL).readValue(json, new TypeReference<List<StringClazz>>() {
        });
        for(Object str:listDeserilized){
            System.out.println(str.hashCode());
        }
        System.out.println(listDeserilized.get(0)==listDeserilized.get(1));
        System.out.println(listDeserilized.get(0)==listDeserilized.get(2));
    }
}

如何解决这个问题？

你没有。反序列化对象意味着在内存中的不同位置创建一个新实例。

但是，我不建议这样做，您可以保留对象的注册表（可能是HashMap），执行反序列化，检查注册表是否包含对象，并用现有的对象替换它。

String类已经通过实习为您提供了一些这种行为。参见String#intern()。

你正在纠结的是平等意味着什么？在Java中有两个版本的相等（与许多现代语言一样）。

这些物品的价值相等吗
这些物体是同一个物体吗？（即通过引用）

这是.equals（）和==之间的差值。当您反序列化某个对象时，它会创建一个新对象，因此如果您有该对象的另一个副本，则会进行序列化。数字2永远不会相等。因为反序列化被赋予了JSON表示，它从中创建了一个新的对象图。

但是，如果您的对象正确地定义了.equals（）对所包含的所有对象的含义，则可能是.equals）。默认情况下，Object.equals（）比较引用，与==相同。但是，每个对象都可以重载它，并且在String.equals（）的情况下比较字符串的实际内容。

因此，只需将代码更改为使用.equals（）而不是==，就可以得到您所期望的：

System.out.println( list.get(0).equals( list.get(1) ) )
System.out.println( list.get(0).equals( list.get(2) ) )

相关内容

最新更新

热门标签：