자바 의 네 가지 복사("얕 은 복사,깊 은 복사"이해)

자바 의 네 가지 복사("얕 은 복사,깊 은 복사"이해)
글 목록

자바 의 네 가지 복사('얕 은 복사,깊 은 복사'이해)

1.'얕 은 복사'와'깊 은 복사'의 차이 점:

두 가지,네 가지 복사:

세 가지,두 가지 유형의 운용:

4.몇 가지 복사 에 대한 소개:

1.for()순환 복사

2.clone()복사

3.System.arraycopy 복사

4.Arrays.copyOf 복사

5.대상 은'기본 유형'(코드)

이다.

6.대상 은'인용 유형'(코드)

이다.
1.'얕 은 복사'와'깊 은 복사'의 차이 점:
얕 은 복사:
원본 대상 의 데이터 형 필드 를 새로운 대상 에 복사 하고 인용 형 필드 의'인용'을 새로운 대상 에 복사 하 며'인용 대상'을 복사 하지 않 기 때문에 원본 대상 과 새로운 대상 이 같은 대상 을 인용 하고 새로운 대상 의 인용 형 필드 가 변화 하면 원본 대상 의 대응 필드 도 변화 할 수 있다.
깊 은 복사:
인용 에 있어 서 다 릅 니 다.깊이 복사 하 는 것 은 원본 필드 와 같은 내용 의 필드 를 만 드 는 것 입 니 다.똑 같은 데이터 세그먼트 이기 때문에 이들 의 인용 은 다 릅 니 다.그 후에 새로운 대상 의 인용 형 필드 가 바 뀌 어 원본 대상 의 필드 가 바 뀌 지 않 습 니 다.
2.네 가지 복사:

for()순환 복사

clone()복사

System.arraycopy()복사

Arrays.copyOf()복사

3.두 가지 유형의 활용:

기본 유형(심 복사):다음 과 같은 예 에서 복사 배열 요 소 를 바 꾸 고 소스 배열 이 변 하지 않 으 면 심 복사

인용 유형(얕 은 복사):다음 과 같은 예 에서 복사 배열 요 소 를 바 꾸 고 소스 배열 이 변 하지 않 으 면 얕 은 복사

4.몇 가지 복사 에 대한 소개:
1.for()순환 복사
순환 할당 을 통 해 메타 배열 의 요 소 를 대상 배열 로 복사 합 니 다.
2.clone()복사
함수 원형 은:
clone

protected Object clone()
                throws CloneNotSupportedException

clone Object 。 ， Cloneable ， CloneNotSupportedException 。 ， Cloneable ， T[] clone T[] ， T 。 ， ， ， 。 。 ， “ ”， “ ” 。
3.System.arraycopy 복사
System 에서 native 정적 방법 인 array copy()를 제공 합 니 다.이 방법 으로 배열 간 의 복 제 를 실현 할 수 있 습 니 다.
함수 원형 은:
arraycopy

public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

매개 변수src-소스 배열.srcPos-소스 배열 의 시작 위치.dest-목표 배열.destPos-목적지 데이터 의 시작 위치.length-복사 할 배열 요소 의 수량length-복사 할 배열 요소 의 수량
4.Arrays.copyOf 복사
함수 원형 은:
Arrays.copyOf

public static <T> T[] copyOf(T[] original,
                             int newLength)

매개 변수 유형T-배열 의 대상 클래스
매개 변수original-복사 할 배열newLength-되 돌아 갈 던 전의 길이
5.대상 은'기본 유형'(코드)
(네 가지 복사 대응 방식 은'딥 복사')
for()순환 복사

//for（）    
import java.util.*;
public class SimpleCharcter {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        int[] brray = new int[array.length];
        for(int i = 0;i < array.length;i++) {
            brray[i] = array[i];
        }
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
        brray[0] = 1000;
        System.out.println("=================");
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
    }
}
/*    ：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
=================
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1000, 2, 3, 4, 5, 6, 7, 8, 9]         （   ）
*/

clone()복사

//clone（）   
import java.util.*;
public class Clone {
    public static void main(String[] args) {
            int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
            int[] brray = array.clone();

            System.out.println(Arrays.toString(array));
            System.out.println(Arrays.toString(brray));
            brray[0] = 1000;
            System.out.println("=================");
            System.out.println(Arrays.toString(array));
            System.out.println(Arrays.toString(brray));

        }
    }
    
    /*    ：
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
=================
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    [1000, 2, 3, 4, 5, 6, 7, 8, 9]         (   )
    */

System.arraycopy （）

//System.arraycopy()
import java.util.*;
public class System_Arraycopy {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        int[] brray = new int[array.length];
        System.arraycopy(array,0,brray,0,array.length);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
        brray[0] = 1000;
        System.out.println("=================");
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
    }
}

/*    ：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
=================
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1000, 2, 3, 4, 5, 6, 7, 8, 9]         （   ）
*/

Arrays.copyOf （）

//Arrays.copyOf 
import java.util.*;
public class TestArray1 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        int[] brray = Arrays.copyOf(array,array.length);

        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
        brray[0] = 1000;
        System.out.println("=================");
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
    }
 }
 
 /*    ：
 [1, 2, 3, 4, 5, 6, 7, 8, 9]
 [1, 2, 3, 4, 5, 6, 7, 8, 9]
 =================
 [1, 2, 3, 4, 5, 6, 7, 8, 9]
 [1000, 2, 3, 4, 5, 6, 7, 8, 9]         （   ）
 */

6.대상 이'참조 형식'(코드)일 때
(네 가지 복사 대응 방식 은'딥 복사')
코드 의 실현 방향:

원본 배열 t1,대상 배열(복사 배열)t2,길 이 는 4

로 정의 합 니 다.

개인 속성 val 을 배열 의 값 으로 정의 합 니 다

배열 을 인쇄 하 는 print 방법 을 정의 합 니 다

main 은 입구 로 복사 하고 print 방법

을 호출 합 니 다.

두 번 인쇄 하고 중간 에 t2[0]의 값 을 바 꾸 면

print(t1, t2);                    //복사 후 바로 인쇄           t2[0].setVal(100000);     //중간 변경 t2[0]           print(t1, t2);                   //인쇄 변경 복사 배열 값,t1,t2 의 첫 번 째 요소 가 모두 바 뀌 었 는 지 확인 합 니 다.
(얕 은 복사:다 변/깊 은 복사:t2 만 변 함)

import java.util.*;
public class TestArray {
    private int val = 10;

    public void setVal(int val) {
        this.val = val;
    }
    public int getVal() {
        return this.val;
    }
    public static void print(TestArray[] t1, TestArray[] t2){
        for(int i = 0;i < t1.length;i++) {
            t2[i] = t1[i];//      ，  t1[i] t2[i]           ，     ，   
        }
        for(int i = 0;i < t1.length;i++) {
            System.out.print(t1[i].getVal()+" ");
        }
        System.out.println();
        for(int i = 0;i < t2.length;i++) {
            System.out.print(t2[i].getVal()+" ");
        }
        System.out.println();
        System.out.println();
    }

for()순환 복사 및 인쇄 결과 코드

//for（）
public static void main(String[] args) {
        TestArray[] t1 = new TestArray[4];//TestArray        
        t1[0] = new TestArray();// t1[0]          
        t1[1] = new TestArray();
        t1[2] = new TestArray();
        t1[3] = new TestArray();
        TestArray[] t2 = new TestArray[4];//t2[0]
        print(t1, t2);
        t2[0].setVal(100000);
        print(t1, t2);
        }
        
        /*    ：
        10 10 10 10
        10 10 10 10
       
        100000 10 10 10
        100000 10 10 10         （   ）
        */

clone（）

//clone()
public static void main(String[] args) {
    TestArray[] t1 = new TestArray[4];
    t1[0] = new TestArray();
    t1[1] = new TestArray();
    t1[2] = new TestArray();
    t1[3] = new TestArray();
    TestArray[] t2 = t1.clone();//t2[0]
    print(t1, t2);
    t2[0].setVal(99999);
    print(t1, t2);
    }
    
    /*    ：
    10 10 10 10 
    10 10 10 10 

    99999 10 10 10 
    99999 10 10 10          (   )
    */

System.arraycopy （）

//System.arraycopy() 
public static void main(String[] args) {
   TestArray[] t1 = new TestArray[4];
   t1[0] = new TestArray();
   t1[1] = new TestArray();
   t1[2] = new TestArray();
   t1[3] = new TestArray();
   TestArray[] t2 = new TestArray[4];//t2[0]
   System.arraycopy(t1,0,t2,0,t1.length);
   print(t1, t2);
   t2[0].setVal(88888);
   print(t1, t2);
   }
   
   /*    ：
   10 10 10 10 
   10 10 10 10 

   88888 10 10 10 
   88888 10 10 10         (   )         
   */

Arrays.copyOf （）

//Arrays.copyOf ()
public static void main(String[] args) {
    TestArray[] t1 = new TestArray[4];
    t1[0] = new TestArray();
    t1[1] = new TestArray();
    t1[2] = new TestArray();
    t1[3] = new TestArray();
    TestArray[] t2 = Arrays.copyOf(t1,t1.length);
    print(t1, t2);
    t2[0].setVal(666666);
    print(t1, t2);
    
    /*    ：
    10 10 10 10 
    10 10 10 10 

    666666 10 10 10 
    666666 10 10 10         (   ) 
    */

                                                     2018.10.19/  
                                                     by 922

​