由Map的复制问题引发对深复制和浅复制的思考

前几天写程序遇到了这样的一个问题：

    Map<String, Object> args=getparameters();

    Map<String, Object> hot_args=args;
    hot_args.put("sortItem","pv");

    Map<String, Object> common_args=args;
    common_args.put("dateId","week");

一直有问题，后来才发现，common_args的sortItem键值和hot_args的键值是一致的，并且在最后，args,hot_args,common_args都是一样的，考虑一番，才想起来这是由于深复制和浅复制的问题：
所谓浅复制：则是只复制对象的引用，两个引用仍然指向同一个对象，在内存中占用同一块内存。被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
深复制：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。
下面是我写的一个实现深复制的案例：（实现对POJO对象的深复制）

    package text.copy;

    public class User implements Cloneable  {
        private String name;
        private String passwd;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getPasswd() {
            return passwd;
        }
        public void setPasswd(String passwd) {
            this.passwd = passwd;
        }
        public Object clone()//重写Cloneable接口的clone()方法
        {
            User user=null;
            try{
                user=(User)super.clone();//将一个实例克隆，并抛出异常
            }catch(CloneNotSupportedException e)
            {
                e.printStackTrace();
            }
            return user;
        }
    }

使用：

    User user1=new User();
    user1.setName("Lily");
    User user2=(User)user1.clone();
    user2.setName("admin");
    System.out.println("user1.name:"+user1.getName());
    System.out.println("user2.name:"+user2.getName());

结果：

    user1.name:Lily
    user2.name:admin

回到最上面，对于Map,我们不好去重写Map类或者HashMap类，但可以通过另外一种方式，HashMap的putAll()来实现：

    Map<String, Object> args=getparameters();

    Map<String, Object> hot_args=new HashMap<String, Object>();
    hot_args.putAll(_args);
    hot_args.put("sortItem","pv");

    Map<String, Object> common_args=new HashMap<String, Object>();
    common_args.putAll(_args);
    common_args.put("dateId","week");

这样，每次都重新创建一个HashMap对象，在改对象上添加键值，三者互不干扰。。。

评论

1 楼 cxzucc 2011-10-20  

楼主的方法有问题，如果User类里面有一个复杂对象的话，就会出现问题了，深克隆的话还是要采用序列化再反序列化的方式来获得吧？个人的意见，不知道有没有错误。
class User2
{
    private String name;
   
    public String getName()
    {
        return name;
    }
   
    public void setName(String name)
    {
        this.name = name;
    }
}

public class User implements Cloneable
{
    private String name;
   
    private String passwd;
   
    private User2 user = new User2();
   
    public String getName()
    {
        return name;
    }
   
    public void setName(String name)
    {
        this.name = name;
    }
   
    public String getPasswd()
    {
        return passwd;
    }
   
    public void setPasswd(String passwd)
    {
        this.passwd = passwd;
    }
   
    public Object clone()// 重写Cloneable接口的clone()方法
    {
        User user = null;
        try
        {
            user = (User)super.clone();// 将一个实例克隆，并抛出异常
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
        return user;
    }
   
    public static void main(String[] args)
    {
        User user1 = new User();
        user1.setName("Lily");
        user1.getUser().setName("Test1");
       
        User user2 = (User)user1.clone();
        user2.setName("admin");
        user2.getUser().setName("Test2");
       
        System.out.println("user1.name:" + user1.getName());
        System.out.println("user2.name:" + user2.getName());
       
        System.out.println("user1.user.name:" + user1.getUser().getName());
        System.out.println("user2.user.name:" + user2.getUser().getName());
    }
   
    public User2 getUser()
    {
        return user;
    }
   
    public void setUser(User2 user)
    {
        this.user = user;
    }
}