[Java] Java 배열 깊은 복사 & 얕은 복사 / Deep Copy & Shallow Copy / Java 객체 배열 복사

 

TITLE

👀 깊은 복사 / 얕은 복사 👀
1.얕은 복사 : 복사한 배열이 원래 배열의 '주솟값'을 가져옴
2.깊은 복사 : 복사한 배열이 원래 배열을 '그대로' 가져옴

Java의 배열 복사에는 깊은 복사(Deep Copy)와 얕은 복사(Shallow Copy)가 있습니다.

 

얕은 복사는 단순한 변수 선언을 통한 복사의 형태로, 복사하려는 배열의 주솟값을 가져오게됩니다.

그래서 복사한 배열을 수정하게 될 경우, 원래 배열 또한 수정되는 결과를 얻게 됩니다.

 

깊은 복사는 원래 배열을 그대로 가져와 새 배열에 덮어쓰기 하는 것입니다.

따라서 복사한 배열을 수정하더라도, 원래 배열이 수정되는일은 없습니다.

 

얕은 복사는 차원 상관없이 단순 변수 선언을 통해 사용할 수 있습니다.

반면 깊은 복사는 1차원의 경우 array.clone()을 이용해 할 수 있는 반면,

2차원의 경우 System.arraycopy()를 이용하거나 2중 반복문을 통해 구현해야 합니다.

객체 배열의 경우 반복문, clone(), arraycopy()를 사용할 수 있습니다.

 

---

<1차원 배열>

얕은 복사

• 원래 배열의 주솟값을 가져옴.
• 복사한 배열 수정시 원래 배열 수정됨.
• 단순 배열 변수 선언을 통한 복사방법이 이에 해당됨. (int[] B = A;)

// 배열 A를 배열 B에 얕은 복사 해볼까요?
int[] A = {1,2,3,4,5};
int[] B = A;

B[0] = 999;

System.out.println("'B'를 바꿨는데 'A'값이 바뀌었네요 : "+A[0]);
// >'B'를 바꿨는데 'A'값이 바뀌었네요 : 999

 

깊은 복사

• 배열 A를 그대로 가져와 새로운 배열을 만듬.
• 복사한 배열(새로운 배열 B)를 수정해도 배열 A는 영향받지 않음.
• A.clone()을 사용하여 깊은 복사할 수 있음.

// A.clone()을 사용하여 깊은 복사
int[] A = {1,2,3,4,5};
int[] B = A.clone();

B[0] = 999;

System.out.println("'B'를 바꿔도 'A'값은 바뀌지 않습니다! : "+A[0]);
// >'B'를 바꿔도 'A'값은 바뀌지 않습니다! : 1
System.out.println("'B' 값은 정상적으로 바뀌었지만요! : "+B[0]);
// >'B' 값은 정상적으로 바뀌었지만요! : 999

 

---

 

<2차원 배열>

얕은 복사

• 단순 변수 선언 뿐만 아니라 A.clone()을 사용해도 얕은 복사가 됨.

int[][] A = {{1,2,3,4,5}, {6,7,8,9,10}};
int[][] B = A; // B : 단순 변수 선언
int[][] C = A.clone(); // C : clone() 사용

B[0][0] = 999;

System.out.println("'B'를 바꾸면 'A'값이 바뀝니다! : "+A[0][0]);
// >'B'를 바꾸면 'A'값이 바뀝니다! : 999

C[0][0] = 777;

System.out.println("'C'를 바꿔도 'A'값이 바뀝니다! : "+A[0][0]);
// >'C'를 바꾸면 'A'값이 바뀝니다! : 777

 

깊은 복사

• 2중 반복문을 사용하여 가능
• 반복문 + System.arraycopy()를 사용하여 가능 
• System.arraycopy(원래 배열, 원래 배열 시작 위치, 새 배열, 새 배열 시작 위치, 길이)

int[][] A = {{1,2,3,4,5}, {6,7,8,9,10}};

// <B> : A와 같은 사이즈로 만든 후, 2중 반복문을 통한 복사
int[][] B = new int[A.length][A[0].length]; // B 선언

for(int i = 0; i < A.length; i++){ // 2중 반복문
for(int j = 0 ; j < A[0].length; j++){
B[i][j] = A[i][j];
}
}

// <C> : A와 같은 사이즈로 만든 후, 반복문 + arraycopy 사용하여 복사
int[][] C = new int[A.length][A[0].length]; // C 선언,

for(int i = 0; i < A.length; i++){ // 반복문 + ArrayCopy
System.arraycopy(A[i], 0, C[i], 0, C[i].length);
}

// <확인>

B[0][0] = 999;
C[0][0] = 777;

System.out.println("'B'를 바꿔도 'A'값이 바뀌지 않습니다! : "+A[0][0]);
System.out.println("'C'를 바꿔도 'A'값이 바뀌지 않습니다! : "+A[0][0]);
// >'B'를 바꿔도 'A'값이 바뀌지 않습니다! : 1
// >'C'를 바꿔도 'A'값이 바뀌지 않습니다! : 1

 

---

 

<객체 배열(1차원)>

얕은 복사

• 변수 선언의 경우 얕은 복사

public class Main {
    public static void main(String[] args){
        Point[] A = {new Point(1,1), new Point(2,2), new Point(3,3)}; // 원래 배열

        Point[] D = A;

        D[0] = new Point(333,333);
        System.out.println("[얕은 복사] D 배열의 값이 바뀌면서("+D[0].x+"), A 배열의 값도 바뀐다!("+A[0].x+")");
        // >[얕은 복사] D 배열의 값이 바뀌면서(333), A 배열의 값도 바뀐다!(333)
    }

    static class Point{ // 좌표계 점 객체 (x,y)
        int x, y;
        public Point(int x,int y){
            this.x = x;
            this.y = y;
        }
    }
}

 

깊은 복사

• A.clone() / System.arraycopy()의 경우 깊은 복사

package Baekjoon;

public class Main {
    public static void main(String[] args){
        Point[] A = {new Point(1,1), new Point(2,2), new Point(3,3)}; // 원래 객체 배열

        Point[] B = A.clone(); // B : clone() 사용

        Point[] C = new Point[A.length]; // C : arraycopy() 사용
        System.arraycopy(A, 0, C, 0, A.length);

        B[0] = new Point(999,999);
        System.out.println("[깊은 복사] B 배열의 값은 바뀌었지만("+B[0].x+"), A 배열의 값은 그대로!("+A[0].x+")");
        // >[깊은 복사] B 배열의 값은 바뀌었지만(999), A 배열의 값은 그대로!(1)

        C[0] = new Point(777,777);
        System.out.println("[깊은 복사] C 배열의 값은 바뀌었지만("+C[0].x+"), A 배열의 값은 그대로!("+A[0].x+")");
        // >[깊은 복사] C 배열의 값은 바뀌었지만(777), A 배열의 값은 그대로!(1)
    }

    static class Point{ // 좌표계 점 객체 (x,y)
        int x, y;
        public Point(int x,int y){
            this.x = x;
            this.y = y;
        }
    }
}

 

<참고>

woovictory.github.io/2020/04/22/Java-Array-Copy/