
public class Employee {
    private String name;
 
    private Address address;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Address getAddress() {
        return address;
    }
 
    public void setAddress(Address address) {
        this.address = address;
    }
 
}

一个Address类


 
public class Address {
    private String name;
 
    private String province;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getProvince() {
        return province;
    }
 
    public void setProvince(String province) {
        this.province = province;
    }
}

测试：


import org.junit.Test;
 
import java.util.HashMap;
 
public class TestHashMapCopy {
    private HashMap<String , Employee> originalMap= new HashMap();
 
    @Test
    public void testShallowCopy() {
        Employee emp1 = new Employee();
        emp1.setName("刘亦菲");
        originalMap.put("emp1", emp1);
 
        Employee emp2 = new Employee();
        emp2.setName("范冰冰");
        originalMap.put("emp2",emp2);
 
        HashMap<String ,Employee> shallowCopy = new HashMap<>(originalMap);
        assert shallowCopy != orignalMap;
 
//        System.out.println("orignalMap beforeChange" + JacksonJsonUtil.obj2JsonString(orignalMap));
//        System.out.println("shallowCopy beforeChange" + JacksonJsonUtil.obj2JsonString(shallowCopy));
        emp1.setName("关晓彤");
        Employee shallowCopyEmp2 = shallowCopy.get("emp2");
        shallowCopyEmp2.setName("emp2改名字");
//        System.out.println("orignalMap afterChange" + JacksonJsonUtil.obj2JsonString(orignalMap));
//        System.out.println("shallowCopy afterChange" + JacksonJsonUtil.obj2JsonString(shallowCopy));
        // assert结果是true，表示浅复制map里的emp1和原map里的emp1是同一个对象，
        // 无论是在浅复制map里更改emp1的属性，还是在原map里更改emp1的属性，对方都会跟着更改
        assert (shallowCopy.get("emp1")).equals(orignalMap.get("emp1"));
    }
}

测试结果：

浅复制，原map和复制map不是同一个对象，但是map里的value如果是引用类型的话，那么该引用类型是同一个对象，比如测试例子中的emp1.

更改了emp1里的属性之后，原map和浅复制map里的emp1属性都变了，会相互影响。

2.2深复制（deep copy）

深复制的HashMap，是一个新的HashMap，并且深复制了所有的属性。它为所有的key、value、mappings创建了新的对象，

因此原map和深复制map更改了值之后，相互不影响。

深复制的实现，比如Apache Commons Lang，但是要求map的所有key和value是实现了Serializable接口。

3、常见实现方式

3.1【浅复制】

3.1.1使用HashMap的构造器

HashMap(Map<? extends K,? extends V> m) ：

HashMap<String ,Employee> shallowCopy = new HashMap<>(originalMap);

3.1.2使用clone()

HashMap<String ,Employee> shallowCopy = (HashMap<String, Employee>) originalMap.clone();

3.1.3Map.put()


HashMap<String ,Employee> shallowCopy = new HashMap<String , Employee>();
        Set<Map.Entry<String, Employee>> entries = originalMap.entrySet();
        for(Map.Entry<String, Employee> entry: entries) {
            shallowCopy.put(entry.getKey(), entry.getValue());
        }

3.1.4Map.putAll()


HashMap<String ,Employee> shallowCopy = new HashMap<String , Employee>();
        shallowCopy.putAll(originalMap);

3.1.5Java 8 Stream API


HashMap<String, Employee> shallowCopy = (HashMap<String, Employee>) originalMap.entrySet().stream().collect(
                // 阿里开发手册里集合处理第3条有写toMap的规范：要使用带有BinaryOperator的方法
                // Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue
                Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (v1, v2) -> v2
                ));

3.1.6Google Guava的copyOf

Map<String, Employee> shallowCopy = ImmutableMap.copyOf(originalMap);

3.2【深复制】

主要是序列化、反序列化方式

3.2.1Apache Commons Lang【不建议使用】

但是要求map的所有key和value都实现了Serializable接口，包括对象里的对象属性也需要

public class Employee implements Serializable {

public class Address implements Serializable {

HashMap<String, Employee> deepCopy = SerializationUtils.clone(originalMap);

3.2.2Json序列化和反序列化【一般推荐】

常见的序列化工具，Jackson、Gson、fastjson等，但是要注意反序列化为Map的时候，需要指定对应的泛型

Jackson：

可以使用Jackson的工具类，封装下列的方法

方式一：含参数TypeReference的方法


        ObjectMapper objectMapper = new ObjectMapper();
        String originalJsonStr = objectMapper.writeValueAsString(originalMap);
        HashMap<String, Employee> deepCopy = new HashMap<>();
        deepCopy = objectMapper.readValue(originalJsonStr, new TypeReference<HashMap<String, Employee>>() {
        });

方式二：使用含参数JavaType的方法


 
        ObjectMapper objectMapper = new ObjectMapper();
        String originalJsonStr = objectMapper.writeValueAsString(originalMap);
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(HashMap.class, String.class, Employee.class);
        HashMap<String, Employee> deepCopy = objectMapper.readValue(originalJsonStr, javaType);

Gson：需要使用泛型参数TypeToken


        // Gson序列化，需要使用泛型参数TypeToken
        Gson gson = new Gson();
        String json = gson.toJson(originalMap);
        HashMap<String, Employee> deepCopy = new HashMap<>();
        // 注意，gson的jsonStr转集合，需要使用泛型参数TypeToken，才能准确获取到需要的对象
        deepCopy = gson.fromJson(json, new TypeToken<HashMap<String, Employee>>(){}.getType());

fastjson：需要使用TypeReference指定泛型


        // fastJson序列化，注意要使用TypeReference指定泛型
        String originalJsonStr = JSON.toJSONString(originalMap);
        HashMap<String, Employee> deepCopy = JSON.parseObject(originalJsonStr,new TypeReference<HashMap<String, Employee>>(){});

3.2.3序列化和反序列化【推荐】

常用的序列化框架：

JDK Serializable、FST、Kryo、Protobuf、Thrift、Hession和Avro、Protostuff，3.7.2里提到的也是，只是是序列化成json结构

序列化框架的详情可以看下另一篇博客【待发布】

以Protostuff为例：

因为Protostuff常规上只支持序列化、反序列化Bean对象，不支持List、Map，因此这里建了一个包装类Wrapper：

注：List、Map，也可以使用MessageCollectionSchema，参考：How do I serialize list or map collection objects? · Issue #233 · protostuff/protostuff · GitHub


public class SerializeWrapper {
 
	private Object obj = null;
 
	public Object getObj() {
		return obj;
	}
 
	public void setObj(Object obj) {
		this.obj = obj;
	}
}


 
        Schema<SerializeWrapper> schema = RuntimeSchema.getSchema(SerializeWrapper.class);
        SerializeWrapper SerializeWrapper = new SerializeWrapper();
        SerializeWrapper.setObj(originalMap);
 
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        final byte[] protostuff;
        try{
            protostuff = ProtostuffIOUtil.toByteArray(SerializeWrapper,schema,buffer);
        } finally {
            buffer.clear();
        }
        ProtostuffIOUtil.mergeFrom(protostuff, SerializeWrapper, schema);
        HashMap<String, Employee> deepCopy = (HashMap<String, Employee>) SerializeWrapper.getObj();

3.3其它

还有其它的框架可以实现，比如HuTool等

4.总结

浅复制的话，上面的浅复制方法都可以选择；深复制的话，推荐使用Protostuff等序列化工具，最好不需要对象实现序列化接口，或者需要转换成json格式。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/68567