Java 浅克隆与深克隆

有一次，在写一个项目

//          for (DateReportBean d : lists) {
//                System.out.println(d.toString());
//          }
//          System.out.println("==========================" + lists.size());
             for (DateReportBean d : lists) {

                   // 门店数组
                   boolean is_add = true;
                   for (String s : shops) {
                         if ( d.getShopName().equals( s)) {
                               is_add = false;
                        }
                  }
                   if ( is_add) {
                         shops.add( d.getShopName());
                  }

                   // 套餐数组
                   is_add = true;
                   for (String g : goods) {
                         if ( d.getGoodName().equals( g)) {
                               is_add = false;
                        }
                  }
                   if ( is_add) {
                         goods.add( d.getGoodName());
                  }

                   // 列表数组
                   is_add = true;
                   for (DateReportBean dT : listT) {
                         if ( d.getGoodName().equals( dT.getGoodName()) && d.getShopName().equals( dT.getShopName())) {
                               is_add = false;

                               dT.setNum( dT.getNum() + d.getNum());
                              System. out
                                          .println( dT.getShopName() + " " + dT .getGoodName() + " " + dT .getNum() + "  " + d .getNum());
                               dT.setPrice( dT.getPrice() + d.getPrice());
                        }
                  }
                   if ( is_add) {
                         listT.add( d);
                  }
            }
//          for (DateReportBean d : lists) {
//          System.out.println(d.toString());
//    }
//    System.out.println("==========================" + lists.size());

两端注释位置 输出值不一样

今天写的代码 lists 没有经过 变值，但两次输出结果却不同。

后来仔细一想，原因：

listT.add( d);主要是这行代码，lists listT 共用了同一个对象，

当listT内部对象变值时，lists的对象也跟着变化

list是一堆指针链，要  复制对象，而原来的list不受影响，只好用克隆。

克隆测试：

package com.test;

import java.io.Serializable;

public class Student implements Serializable{
      private String name = null;

      public String getName() {
             return name;
      }

      public void setName(String name) {
             this. name = name;
      }
}

package com.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Teacher implements Cloneable ,Serializable{
     private Student stu  = null;
     private String str = null;
    
     /**
     *浅克隆
     */
     public Object Clone(){
         
          try {
               return super.clone();
          } catch (CloneNotSupportedException e) {
               // TODO Auto-generated catch block
               return null;
          }
         
     }
    
     /**
     * 深克隆
     */
     public Object deepClone() throws IOException, ClassNotFoundException{
          ByteArrayOutputStream bOut = new ByteArrayOutputStream();
          ObjectOutputStream oOut = new ObjectOutputStream(bOut);
          oOut.writeObject(this);
         
          ByteArrayInputStream bIn = new ByteArrayInputStream(bOut.toByteArray());
          ObjectInputStream oIn = new ObjectInputStream(bIn);
         
          return oIn.readObject();
     }
    
     public Student getStu() {
          return stu;
     }
     public void setStu(Student stu) {
          this.stu = stu;
     }
     public String getStr() {
          return str;
     }
     public void setStr(String str) {
          this.str = str;
     }
}

package com.test;

import java.io.IOException;

public class Test {
      public static void main(String[] args) throws ClassNotFoundException, IOException {
             //实现Teacher对象，并赋值
            Student s = new Student();
             s.setName( "zhangsan");
            Teacher t01 = new Teacher();
             t01.setStu( s);
             t01.setStr( "123");
            
            System. out.println( "------------------>进行浅克隆" );
             //浅克隆 --->只能对基本类型克隆
            Teacher t02 = (Teacher) t01.Clone();
            System. out.println( t01.getStr().hashCode() == t02.getStr().hashCode()); //原因吗，编程思想
             t02.setStr( "123456");
            System. out.println( t01.getStr());
            
            System. out.println( t01.getStu().hashCode() == t02.getStu().hashCode());
             t02.getStu().setName( "lisi");
            System. out.println( t01.getStu().getName());
            
            System. out.println( "------------------>进行深克隆" );
             //深度克隆 ---> 可对非基本类型克隆
            Teacher t03 = (Teacher) t01.deepClone();
            System. out.println( t01.getStr().hashCode() == t03.getStr().hashCode()); //原因吗，编程思想
             t03.setStr( "123456789");
            System. out.println( t01.getStr());
            
            System. out.println( t01.getStu().hashCode() == t03.getStu().hashCode());
             t03.getStu().setName( "wangwu");
            System. out.println( t01.getStu().getName());
            
      }
}

⑴浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不

复制它所引用的对象。

⑵深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原

有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。