对象的深度复制和浅复制 （深度拷贝和浅拷贝）

对象的深度复制和浅复制

（深度拷贝和浅拷贝）

作者：Jesai

时间：2018年2月11日 21:46:22

我们在实际的开发项目里面为了使得开发更加的便捷和方便，总会不经意的使用一些第三方的持久化框架(Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），比如C#里面的ADO.NET Entity Framework、Nhibernate以及java里面的MyBaits和Hibernate等等，有时候，我们需要复制一个持久化对象，然后再持久化到数据库里面去，往往有同学是这么操作的，下面我以java的Hibernate为例子。

 

public Car getCarById(Long id) {  
    Criteria criteria = getSession().createCriteria(Car.class);  
    criteria.add(Restrictions.eq("id", id));  
    return (Car)criteria.uniqueResult();  
}  

 

通过上面代码我们等到一个Car的持久化对象。然后我现在要新增一辆一模一样的车，除了车牌号不一样和ID主键不一样。我们是怎么做的呢，首先，刚写编程不久的同学就想到了下面的方法

 

public void Save(Car car) {  
    Car carNew=new Car();
     carNew.Id=”1”;
     carNew.Color= car. Color;
     carNew.Price= car. Price;
     carNew.No=”33333”;
     ……
    getSession().Save(car);   
}  

 

 

这是新手最喜欢用的方式，但是对于一个老程序员来说，他们可不想写那么长长的一段代码，老程序员的思想总是写最少的代码，干更多的事情。于是，有“聪明”的同学是这么做的

 

public void Save(Car car) {  
    Car carNew=new Car();
     carNew =car;
     carNew.Id=”3”;
     carNew.No=”33333”;
    getSession().Save(car);   
}  

 

 

的确是简洁了很多呢，当这个同学很兴奋的去执行测试的时候就会发现Hibernate报错，

我们总会在平常的工作里遇到对象克隆的问题。也许有很多同学会被这个问题所困扰。这到底是怎么回事呢？

 

这就需要用值引用和地址引用的知识来解释这个现象了，我们先来看看什么是值引用和地址引用，

引用传递的是对象的地址，值传递的是变量的值

使用引用传递，被调用函数使用的是调用函数传入的对象本身，也就是说在被调用函数中对对象进行修改将直接导致外部对象的值被修改。
而值传递，传递进去的是变量的副本（即拷贝），此时在被调用函数中对形参的任何修改都不会改变外部变量的值。

值传递是传递数据：如基本数据类型都是值传递

引用传递是把形参和实参的指针指向了堆中的同一对象，对象的引用和数组的引用。

如

Int a=10；

Int b=a；

a=20;

 

变量和对象的实例化的时候都会在计算机的内存里面申请一个内存，值引用是a和b各自申请一个区域存放数据。当a再次改变值的时候，b并不会随着a的改变而改变。

 

Student s=new Student();

s.Name=”Tom”;

Student s1=new Student();

s1=s；

s．Name=“Jon”；

 

对象就是地址引用，在这里，当后面s的Name发生改变的时候，s1也是跟随着改变的。

 

 

值引用

 

 

地址引用

 

在上面图示我们可以看出，值引用是各自分配内存的，本质上不是同一个东西。就好比一对双胞胎，长得很像，但是根本是两个人。而地址引用就好比李明有一个小名叫小明。但是小明和李明都是同一个人。

什么是值传递，地址传递和引用传递？首先，看以下三段代码。

void Test(int x, int y)    
{  
  int tmp=x;  
  x=y;  
  y=tmp;  
  print(“x=%d, y=%d\n”, x, y);  
}  
  
void main()  
 {  

   int a=4,b=5;  
   Test(a,b) ;  
   printf(“a=%d, b=%d\n”, a, b);  
 }  

 

输出结果

x=4, y=5

a=5, b=4

void Test(int *px, int *py)  
{  
  int tmp=*px;  
  *px=*py;  
  *py=tmp;  
  print(“*px=%d, *py=%d\n”, *px, *py);  
}  
  
void main()  
 {  

  int a=4;  
   int b=5;  
   swap2(&a,&b);  
  Print(“a=%d, b=%d\n”, a, b);  
 }  

 

这次输出结果

*px=5, *py=5

a=5, b=4

void Test(int &x, int &y)  
{  
  int tmp=x;  
  x=y;  
  y=tmp;  
  print(“x=%d, y=%d\n”, x, y);  
}  
  
void main()  
 {  

   int a=4;  
   int b=5;  
   swap3(a,b);  
  Print(“a=%d, b=%d\n”, a, b);  
 }  

 

这次输出结果是

---

x=5, y=4

a=5, b=4

上面的分别是值传递，地址传递，和引用传递。

先看值传递。是将x，y进行对调。需要注意的是，对形参的操作不会影响到a，b。当a，b把值赋给x，y之后，对x，y发生改变，不会影响到a，b本身。

 

再看地址传递。a的地址代入到了px，b的地址代入到了py。这样一来，对*px, *py的操作就是a，b本身的操作。所以a，b的值被对调了。

 

引用传递。定义的x，y前面有&取地址符，a，b分别代替了x，y，即x，y分别引用了a，b变量。因此，函数里的操作，实际上是对实参a，b本身的操作，其值发生了对调。

我们怎么判断两个对象是相等（深复制）的呢？可以使用object.ReferenceEquals(s1, s2)。

好了，那么下面我们回来探讨一下对象的深度克隆和浅克隆的几种方法：

写一个Sudent类：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace Model.test

{

    [Serializable]

    public class Student

    {

        public Student() { }

        private string _name;

        private string _age;

        private string _sex;

        private string _address;

        private string _tel;

        public Student(string name, string age, string sex, string address, string tel)

        {

            this.address = address;

            this.age = age;

            this.name = name;

            this.sex = sex;

            this.tel = tel;

        }

        public string name { get; set; }

        public string age { get; set; }

        public string sex { get; set; }

        public string address { get; set; }

        public string email { get; set; }

        public string tel { get; set; }

    }

}

 

我们先来看看对象直接赋值：

        

 static void Main(string[] args)

        {
            Student s1 = new Student();

            s1.address = "北京";

            s1.sex = "男";

            s1.tel = "18825196284";

            s1.name = "张峰";

            s1.email = "777663548@QQ.COM";

            s1.age = "25";

            Student s2 = new Student();

            s2 = s1;

            //更改s2的年龄

            s2.age = "44";

            Console.WriteLine("s1的年龄：" + s1.age + " S2 HashCode:" + s2.GetHashCode() + "   S1 HashCode:" + s1.GetHashCode() + "   直接复制  s2 = s1 的ReferenceEquals结果：" + object.ReferenceEquals(s1, s2));

            Console.ReadLine();

        }

 

 

结果说明这两个对象是地址引用，即浅复制。

再来看下面的情况：

          

static void Main(string[] args)

        {

            Student s1 = new Student();

            s1.address = "北京";

            s1.sex = "男";

            s1.tel = "18825196284";

            s1.name = "张峰";

            s1.email = "777663548@QQ.COM";

            s1.age = "25";
            Student s2 = new Student();

            s2.address = s1.address;

            s2.sex = s1.sex;

            s2.tel = s1.tel;

            s2.name = s1.name;

            s2.email = s1.email;

            s2.age = s1.age;

            //更改s2的年龄

            s2.age = "55";
            Console.WriteLine("s1的年龄：" + s1.age + " S2 HashCode:" + s2.GetHashCode() + "   S1 HashCode:" + s1.GetHashCode() + "   直接复制  s2 = s1 的ReferenceEquals结果：" + object.ReferenceEquals(s1, s2));

            Console.ReadLine();

        }

 

 

 

可以看出来属性一个一个赋值是深度克隆，但是这样代码量就大了。那么有什么办法写很少的代码吗？

第一种方法-对象映射：

public static object CloneObject(object o)

        {

            Type t = o.GetType();

            PropertyInfo[] properties = t.GetProperties();

            Object p = t.InvokeMember("", System.Reflection.BindingFlags.CreateInstance, null, o, null);

            foreach (PropertyInfo pi in properties)

            {

                if (pi.CanWrite)

                {
                    object value = pi.GetValue(o, null);

                    pi.SetValue(p, value, null);

                }

            }

            return p;

        }

        static void Main(string[] args)

        {

            Student s1 = new Student();

            s1.address = "北京";

            s1.sex = "男";

            s1.tel = "18825196284";

            s1.name = "张峰";

            s1.email = "777663548@QQ.COM";

            s1.age = "25";

            Student s2 = new Student();

            s2 = (Student)CloneObject(s1);

            //更改S2的年龄

            s2.age = "88";
            Console.WriteLine("s1的年龄：" + s1.age + " S2 HashCode:" + s2.GetHashCode() + "   S1 HashCode:" + s1.GetHashCode() + "   直接复制  s2 = s1 的ReferenceEquals结果：" + object.ReferenceEquals(s1, s2));

            Console.ReadLine();

        }

 

 

第二种方法（二进制流序列化反序列化）：

       

 static void Main(string[] args)

        {

            Student s1 = new Student();

            s1.address = "北京";

            s1.sex = "男";

            s1.tel = "18825196284";

            s1.name = "张峰";

            s1.email = "777663548@QQ.COM";

            s1.age = "25";  

            Student s2 = new Student();

            BinaryFormatter inputFormatter = new BinaryFormatter();

            MemoryStream inputStream;

            using (inputStream = new MemoryStream())

            {

                inputFormatter.Serialize(inputStream, s1);
            }

            //将二进制流反序列化为对象 

            using (MemoryStream outputStream = new MemoryStream(inputStream.ToArray()))

            {
                BinaryFormatter outputFormatter = new BinaryFormatter();

                s2 = (Student)outputFormatter.Deserialize(outputStream);

            } 

            //更改S2的年龄

            s2.age = "88";

            Console.WriteLine("s1的年龄：" + s1.age + " S2 HashCode:" + s2.GetHashCode() + "   S1 HashCode:" + s1.GetHashCode() + "   直接复制  s2 = s1 的ReferenceEquals结果：" + object.ReferenceEquals(s1, s2));

            Console.ReadLine();

        }

 

 

第三种（AutoMapper）：

using System;

using System.Collections;

using System.Collections.Generic;

using System.Data;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace AutoMapper.AutoMapperHelpers

{

/// <summary>

    /// AutoMapper扩展帮助类

    /// </summary>

    public static class AutoMapperHelper

    {

        /// <summary>

        ///  类型映射

        /// </summary>

        public static T MapTo<T>(this object obj)

        {

            if (obj == null) return default(T);

            Mapper.CreateMap(obj.GetType(), typeof(T));

            return Mapper.Map<T>(obj);

        }

        /// <summary>

        /// 集合列表类型映射

        /// </summary>

        public static List<TDestination> MapToList<TDestination>(this IEnumerable source)

        {

            foreach (var first in source)

            {

                var type = first.GetType();

                Mapper.CreateMap(type, typeof(TDestination));

                break;

            }

            return Mapper.Map<List<TDestination>>(source);

        }

        /// <summary>

        /// 集合列表类型映射

        /// </summary>

        public static List<TDestination> MapToList<TSource, TDestination>(this IEnumerable<TSource> source)

        {

            //IEnumerable<T> 类型需要创建元素的映射

            Mapper.CreateMap<TSource, TDestination>();

            return Mapper.Map<List<TDestination>>(source);

        }

        /// <summary>

        /// 类型映射

        /// </summary>

        public static TDestination MapTo<TSource, TDestination>(this TSource source, TDestination destination)

            where TSource : class

            where TDestination : class

        {

           if (source == null) return destination;

            Mapper.CreateMap<TSource, TDestination>();

            return Mapper.Map(source, destination);

        }

        /// <summary>

        /// DataReader映射

        /// </summary>

        public static IEnumerable<T> DataReaderMapTo<T>(this IDataReader reader)

        {

            Mapper.Reset();

            Mapper.CreateMap<IDataReader, IEnumerable<T>>();

            return Mapper.Map<IDataReader, IEnumerable<T>>(reader);

        }

    }

}

static void Main(string[] args)

        {

            Student s1 = new Student();

            s1.address = "北京";

            s1.sex = "男";

            s1.tel = "18825196284";

            s1.name = "张峰";

            s1.email = "777663548@QQ.COM";

            s1.age = "25";

            Student s2 = new Student();

            s2 = AutoMapperHelper.MapTo<Student>(s1);

            //更改S2的年龄
            s2.age = "88";

            Console.WriteLine("s1的年龄：" + s1.age + " S2 HashCode:" + s2.GetHashCode() + "   S1 HashCode:" + s1.GetHashCode() + "   直接复制  s2 = s1 的ReferenceEquals结果：" + object.ReferenceEquals(s1, s2));

            Console.ReadLine();

        }

 

第四种JSON序列化和反序列化：

   

static void Main(string[] args)

        {

            Student s1 = new Student();

            s1.address = "北京";

            s1.sex = "男";

            s1.tel = "18825196284";

            s1.name = "张峰";

            s1.email = "777663548@QQ.COM";

            s1.age = "25";

            Student s2 = Newtonsoft.Json.JsonConvert.DeserializeObject<Student>(Newtonsoft.Json.JsonConvert.SerializeObject(s1));

            //更改S2的年龄

            s2.age = "88";

            Console.WriteLine("s1的年龄：" + s1.age + " S2 HashCode:" + s2.GetHashCode() + "   S1 HashCode:" + s1.GetHashCode() + "   直接复制  s2 = s1 的ReferenceEquals结果：" + object.ReferenceEquals(s1, s2));

            Console.ReadLine();

        }