Java深拷贝和浅拷贝Map对象

Posted 2023-02-04 赵广陆

目录

• 1 将Map深拷贝到另一个Map对象当中
• 2 Map的两种拷贝类型
• 3 浅拷贝Map

---

1 将Map深拷贝到另一个Map对象当中

今天赋值的时候遇到的小坑

1.相关文章推荐：
Java克隆方式避免频繁创建对象优化方案 https://blog.csdn.net/ZGL_cyy/article/details/126556907

2.代码实现

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
 * 复制map对象
 * @explain 将paramsMap中的键值对全部拷贝到resultMap中；
 * paramsMap中的内容不会影响到resultMap（深拷贝）
 * @param paramsMap
 *     被拷贝对象
 * @param resultMap
 *     拷贝后的对象
 */
public static void mapCopy(Map paramsMap, Map resultMap) 
    if (resultMap == null) resultMap = new HashMap();
    if (paramsMap == null) return;

    Iterator it = paramsMap.entrySet().iterator();
    while (it.hasNext()) 
        Map.Entry entry = (Map.Entry) it.next();
        Object key = entry.getKey();
        resultMap.put(key, paramsMap.get(key) != null ? paramsMap.get(key) : "");

    

3.测试

public class TestDemo 
    public static void main(String[] args) 

            Map<String, String> map = new HashMap<String, String>(1);
            map.put("name", "oldlu");
            Map<String, Object> map2 = new HashMap<String, Object>(1);
            map2.put("age", new Integer(28));
            // 测试一：是否实现拷贝
            mapCopy(map2, map);
            System.out.println(map);
            System.out.println(map2);
            // 测试二：拷贝后的map对象是否受原map对象的影响
            map2.clear();
            System.out.println(map);
            System.out.println(map2);


    
   

结果如图

回复下方评论

  public static void main(String[] args) 
        Map<String, String> map = new HashMap<String, String>(1);
        map.put("name", "oldlu");
        Map<String, Object> map2 = new HashMap<String, Object>(1);
        map2.put("age", new Integer(28));
        // 测试一：是否实现拷贝
        mapCopy(map2, map);
        System.out.println(map);
        System.out.println(map2);
        // 测试二：拷贝后的map对象是否受原map对象的影响
//        map2.clear();
        map.clear();
        System.out.println(map);
        System.out.println(map2);
    

    public static void mapCopy(Map paramsMap, Map resultMap) 
        if (resultMap == null) resultMap = new HashMap();
        if (paramsMap == null) return;

        Iterator it = paramsMap.entrySet().iterator();
        while (it.hasNext()) 
            Map.Entry entry = (Map.Entry) it.next();
            Object key = entry.getKey();
            resultMap.put(key, paramsMap.get(key) != null ? paramsMap.get(key) : "");

        
    

测试结果

第一种是深拷贝么？你把原来的map clear一下会不会影响copy的map，并不会，Iterator复制的map则不受源map改变的影响，iterator遍历添加的方式，由于是重新创建了一个对象，且遍历添加源Map的元素，因此在内存中另开辟了一块内存是深拷贝；

2 Map的两种拷贝类型

Map的拷贝分为两种情况：

• 浅拷贝：只拷贝对象的引用，两个引用仍然指向同一个对象，在内存中占用同一块内存。被拷贝对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即浅拷贝仅仅拷贝对象的引用，而不拷贝它所引用的对象。
• 深拷贝：被拷贝对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被拷贝过的新对象，而不再是原有的那些被引用的对象。即深拷贝把要拷贝的对象所引用的对象都拷贝了一遍。

针对map中的数据为统一的、简单的基本数据类型，当拷贝的数据通过『 = 』复制map的方法为浅拷贝，在 Java 中，除了基本数据类型（元类型）之外，还存在类的实例对 这个引用数据类型。而一般使用 『 = 』号做赋值操作的时候。对于基本数据类型，实际上是拷贝的它的值，但是对于对象而言，其实赋值的只是这个对象的引用，将原对象的引用传递过去，他们实际上还是指向的同一个对象。putAll方法为深拷贝，iterator遍历添加的方式为深拷贝。

3 浅拷贝Map

1 测试代码

public class TestDemo 
    public static void main(String[] args) 
        // 赋值操作：=只能实现浅拷贝，map中的内容发生变化，copyMap中的内容亦同步发生变化
        Map<String, String> map = new HashMap<String, String>(1);
        map.put("name", "oldlu");
        Map<String, String> copyMap = new HashMap<String, String>(1);
        // 实现浅拷贝的方式：使用=
        copyMap = map;
        map.remove("name");
        System.out.println("map:" + map);
        System.out.print("copyMap:" + copyMap);
    
  

测试结果

2 使用putAll方法

强调：简单的基本数据类型，putAll方法为深拷贝

public class TestDemo 
    public static void main(String[] args) 

         Map<String, Object> map = new HashMap<>();
            Map<String, Object> mapCopy = new HashMap<>();

            Map mapInner = new HashMap();
            mapInner.put("num", 100);
            map.put("key1", mapInner);
            map.put("key2", 200);


            mapCopy.putAll(map);
            System.out.println(map);
            System.out.println(mapCopy);

            ((Map) mapCopy.get("key1")).put("num", 300);
            map.put("key2", 300);
            System.out.println(mapCopy);
            System.out.println(map);
  

运行结果

也就是说两个map如果存的是对象putAll指向同一块内存，当内存的对象发生变化都会变化，，所以是浅拷贝，但是当你put新对象但是key相同的时候他两就不是指向同一块区域了，就是完全独立的两个map，本来想简单写写这个简单的文章，也是看到回复对于这块知识有所欠缺所以好好写一下。

putAll() 源码

    /**
     * Copies all of the mappings from the specified map to this map.
     * These mappings will replace any mappings that this map had for
     * any of the keys currently in the specified map.
     *
     * @param m mappings to be stored in this map
     * @throws NullPointerException if the specified map is null
     */
    public void putAll(Map<? extends K, ? extends V> m) 
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;

        /*
         * Expand the map if the map if the number of mappings to be added
         * is greater than or equal to threshold.  This is conservative; the
         * obvious condition is (m.size() + size) >= threshold, but this
         * condition could result in a map with twice the appropriate capacity,
         * if the keys to be added overlap with the keys already in this map.
         * By using the conservative calculation, we subject ourself
         * to at most one extra resize.
         */
        if (numKeysToBeAdded > threshold) 
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            if (newCapacity > table.length)
                resize(newCapacity);
        

        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    

通过源码可以看到putAll() 方法的实现仅仅是将源Map的第一层put进Map中，这种方式对于value为基本类型的map复制是实现深拷贝的效果的，但是当value为对象时，是不会奏效的

简单的说就是被拷贝的对象改变是否影响源对象，影响就是浅拷贝，不影响就是深拷贝。