116.Java对象的拷贝

对象拷贝

对象的浅拷贝

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

 

public class Student implements Cloneable{
         String name;
         int age;
     Student(String name,int age){
          this.name=name;
          this.age=age;
     }
     
     public Object clone(){
          Object o =null;
          try{
           o=super.clone();//Object中的clone()识别出你要复制的哪一个对象
          }
          catch(CloneNotSupportedException e){
           System.out.println(e.toString());
          }
          return o;
     }
 
 public static void main(String[] args){
      Student s1 = new Student("zhang",18);
      Student s2 = (Student)s1.clone();
      s2.name="li";
      s2.age=20;
      System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后不影响学生1的值
   }
}

对象深拷贝

深复制(深克隆)被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量，那些引用其他对象的变量将指向被复制过的新对象，而不再试原有的那些被引用的对象，换言之，深复制把要复制的对象所引用的对象都复制了一遍。

把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。

在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。

public Object deepClone()
{
 //将对象写到流里
     ByteArrayOutoutStream bo=new ByteArrayOutputStream();
     ObjectOutputStream oo=new ObjectOutputStream(bo);
     oo.writeObject(this);
     //从流里读出来
     ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
     ObjectInputStream oi=new ObjectInputStream(bi);
     return(oi.readObject());
}

 

内存溢出

由于Java具备自动的垃圾回收机制,当我们使用完对象之后,它们会被自动回收,是不是我们在Java程序中不需要再考虑内存管理了吗?

请看如下程序:

class Stack {
    private Object[] elements;
    // 初始化角标
    int index = 0;
    // 默认初始化容量
    private int initialCapacity = 10;

    public Stack() {
        elements = new Object[initialCapacity];
    }

    // 压栈 push
    public void push(Object e) {
        ensureCapacity();
        elements[index++] = e;
        // System.out.println(index);
    }

    // 弹栈 pop
    public Object pop() {
        if (index == 0) {
            throw new RuntimeException("没有元素");
        }
        return elements[--index];
    }

    private void ensureCapacity() {
        if (index == elements.length) {
            elements = Arrays.copyOf(elements, index * 2 + 1);
        }
    }
}

注意:从栈中弹出的对象不会作为垃圾回收,即使程序不再使用这些对象,因为栈内部继续维护着这些对象.最终可能会导致内存占用的不断增加,程序性能降低.这就是内存泄漏.

改进版本

class Stack {
    private Object[] elements;
    // 初始化角标
    int index = 0;
    // 默认初始化容量
    private int initialCapacity = 10;

    public Stack() {
        elements = new Object[initialCapacity];
    }

    // 压栈 push
    public void push(Object e) {
        ensureCapacity();
        elements[index++] = e;
        // System.out.println(index);
    }

    // 弹栈 pop
    public Object pop() {
        if (index == 0) {
            throw new RuntimeException("没有元素");
        }
        Object obj = elements[--index];
        elements[index] = null;
        return obj;
    }

    private void ensureCapacity() {
        if (index == elements.length) {
            elements = Arrays.copyOf(elements, index * 2 + 1);
        }
    }
}