[이펙티브 자바] Item13. clone 재정의는 주의해서 진행하라. (가변 객체 clone 정의하는 방법)

 

item13. clone 재정의는 주의해서 진행하라. 

 

 

https://hyejin.tistory.com/1039

[이펙티브 자바] Item13. clone 재정의는 주의해서 진행하라. (Clone규약)

-> 위의 게시글의 예시처럼 불변 클래스는 Cloneable 인터페이스를 구현하고, clone()을 재정의해주면 되는데 

clone()은 단순히 객체에 저장된 값을 그대로 복사할 뿐, 객체가 참조하고 있는 객체까지 복사하지는 않기 때문에

가변 객체의 경우에는 주의할 점이 있다. 

 

 

shallow copy 얕은 복사 

: 원본과 복사본이 같은 객체를 공유한다. -> 원본을 변경하면 복사본에도 영향을 받는다. 

package chapter02.item13;

import java.security.Signature;
import java.util.Arrays;
import java.util.EmptyStackException;

/**
 * item13. clone 재정의는 주의해서 진행하라.
 * 가변 객체 clone 정의하는 방법 - shallow copy
 */
public class Stack  implements Cloneable{
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack() {
        this.elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object o) {
        ensureCapacity();
        elements[size++] = o;
    }

    public Object pop() {
        if (size == 0) {
            throw new EmptyStackException();
        }

        Object result = elements[--size];
        elements[size] = null; // 다 쓴 참조 해제
        return result;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public Stack clone()  {
        try {
            Stack result = (Stack) super.clone();
            return result;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    // 원소를 위한 공간을 적어도 하나 이상 확보한다.
    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }

    public static void main(String[] args) {
        Object[] values = new Object[2];
        values[0] = new PhoneNumber(123, 456, 7890);
        values[1] = new PhoneNumber(321, 765, 4321);

        Stack stack = new Stack();
        for (Object arg : values) {
            stack.push(arg);
        }

        Stack copy = stack.clone();

        System.out.println("pop from stack");
        while (!stack.isEmpty()) {
            System.out.println(stack.pop() + " ");
        }
        System.out.println();

        System.out.println("pop from copy");
        while (!copy.isEmpty()) {
            System.out.println(copy.pop() + " ");
        }

        System.out.println();
        System.out.println("stack.elements[0] == copy.elements[0] = " + (stack.elements[0] == copy.elements[0]));
    }
}

만약 clone() 을 위와 같이 한다하면 원본과 복사본이 같은 elements를 공유하기 때문에 

-> 이미 stack에서 값을 다 꺼냈기 때문에 copy에서는 꺼낼 값이 없어서 Null이 나오며 stack의 elements와 copy의 elements 를 비교할 때 true가 반환되는 것도 확인할 수 있다. 

 

@Override
public Stack clone()  {
    try {
        Stack result = (Stack) super.clone();
        // elements.clone()을 하지않으면 stack과 copy가 동일한 배열을 사용하게 된다!!
        // 근데 배열은 여전히 동일한 인스턴스를 보고 있다.
        // stack -> elementS[0, 1]
        // copy -> elementC[0,1]
        // elementS[0] == elementC[0]
        result.elements = elements.clone();
        return result;
    } catch (CloneNotSupportedException e) {
        throw new RuntimeException(e);
    }
}

그럼 clone을 위와 같이 재정의해준다고 하면 

copy에도 elements 를 복사해서 꺼낼 수 있지만, stack.elements 와 객체 비교를 보면 true가 호출된다..!! 

이런 경우에는 deep copy 가 필요하다. 

 

 

deep copy  깊은 복사 

: 원본이 참조하고 있는 객체까지 복사하여 원본을 변경하더라도 복사본에 영향이 없게 하는 복사이다. 

package chapter02.item13;

/**
 * item13. clone 재정의는 주의해서 진행하라.
 * 가변 객체 clone 정의하는 방법 - deep copy
 */
public class HashTable implements Cloneable {

    private Entry[] buckets = new Entry[10];

    private static class Entry {
        final Object key;
        Object value;
        Entry next;

        public Entry(Object key, Object value, Entry next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public void add(Object key, Object value) {
            this.next = new Entry(key, value, null);
        }

        // 재귀적인 방법은 StackOverflow를 발생시킬 수 있기 때문에..
        public Entry deepCopy() {
            return new Entry(key, value, next == null ? null : next.deepCopy());
        }


    }



    // deep copy clone
    @Override
    public HashTable clone() {
        HashTable result = null;
        try {
            result = (HashTable) super.clone();
            result.buckets = new Entry[this.buckets.length]; // clone 용 배열 새로 만들어줌

            for (int i = 0; i < this.buckets.length; i++) {
                if (buckets[i] != null) {
                    result.buckets[i] = this.buckets[i].deepCopy();
                }
            }
            return result;

        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    public static void main(String[] args) {
        HashTable hashTable = new HashTable();
        Entry entry = new Entry(new Object(), new Object(), null);
        hashTable.buckets[0] = entry;

        HashTable clone = hashTable.clone();
        System.out.println("(hashTable.buckets[0] == entry) = " + (hashTable.buckets[0] == entry));
        System.out.println("hashTable.buckets[0] == clone.buckets[0] = " + (hashTable.buckets[0] == clone.buckets[0]));
    }
}

depp copy 메서드를 만들어주고, clone 할 때 clone용 배열을 새로 만들어주고 그 배열에 값을 넣어준다. 

근데 이때 위에서 만든 deep copy는 재귀함수라 배열의 크기만큼 해당 메서드를 호출하면 크기가 큰 배열이라면 stackOverflow가 발생할 수 있기 때문에 

재귀함수보다는 다른 방법을 사용하는 것이 좋다. 

 

public Entry deepCopy() {
    Entry result = new Entry(key, value, next);
    for (Entry p = result; p.next != null; p = p.next) {
        p.next = new Entry(p.next.key, p.next.value, p.next.next);
    }

    return result;
}

이렇게 구현한 후에 main 메서드를 돌려보면 

이제 배열의 값도 다른것을 확인할 수 있다.