배열 안에 배열값을 넣어서 배열 하나를 지정하고 그 안에 다시 배열값을 꺼내는 방식으로

[][] 이어서 꺼내온다

이중 for문을 이용하여 각 과목의 합계를 누적 합산하여 총점을구하고

해당 총점을 통해 length로 총점을 나눌 수를 구하여 avg를 계산

// 학생별 평균,총점
        int[][] score01 = {
                         {100,100,100}
                        ,{20,20,20}
                        ,{30,30,30}
                        ,{40,40,40}
                        ,{50,50,50}
                        };

        // 과목별 총점
        int korTotal = 0, engTotal = 0, mathTotal = 0;
        System.out.println("번호 국어 영어 수학 총점 평균");
        System.out.println("=============================");

        for(int i=0; i < score01.length;i++){
            int sum = 0;        // 각 개인 총점
            float avg = 0.0f;   // 각 개인 평균

            korTotal += score01[i][0];
            engTotal += score01[i][1];
            mathTotal += score01[i][2];
            System.out.printf("%3d", i+1); // 3d는 왼쪽으로 세칸 공간차지 // 번호 1~5 출력

            for(int jj=0;jj < score01[i].length;jj++) {
                sum += score01[i][jj];
                System.out.printf("%5d", score01[i][jj]);
            }

            avg = sum/(float)score01[i].length;  // 평균계산
            System.out.printf("%5d %5.1f%n", sum, avg);

        System.out.println("=============================");
        System.out.printf("총점:%3d %4d %4d%n", korTotal, engTotal, mathTotal);
/*  
    출력 결과

            번호 국어 영어 수학 총점 평균
            =============================================
            1  100  100  100  300 100.0
            =============================
            총점:100  100  100
            2   20   20   20   60  20.0
            =============================
            총점:120  120  120
            3   30   30   30   90  30.0
            =============================
            총점:150  150  150
            4   40   40   40  120  40.0
            =============================
            총점:190  190  190
            5   50   50   50  150  50.0
            =============================
            총점:240  240  240

*/
            
        }

new 연산자 다음 vo클래스명 작성하고 그 다음 소괄호, 중괄호 같은 것들이 아직 헷갈리는 중

첫번째 할 때는 그냥 일반 배열에서의 초기화 3가지 방법에 대해 잘 적용하지 못했고 생각도 잘못했는데

2번째 되면서 방법2인 중괄호 방법도 적용 시키는데 성공하고 좀 틀이 잡힌 느낌

숙련도가 올라가는 느낌이 든다

/******************************** Object Array practice 2nd ***************************************/	
	
	public void objectArr02() {
		
		// 객체배열
		//
		// 배열 선언 : Stack 영역에 공간 생성(변수의 선언 : stack에 공간 차지)
		// 배열 할당 : heap 영역에 공간 생성
		// 배열 초기화 : 인덱스,중괄호,for문
		// 배열 삭제 : null
		// 배열 값 출력하는 방법 2가지 : for문 + vo클래스 toString메소드
		
		// 배열 선언
		Person[] oArr;
		
		// 배열 선언 & 할당
		Person[] obArr = new Person[3];
		
		// 배열 초기화
		// 	방법1 : index
		obArr[0] = new Person("킴",20,'M',173,69);		// 중괄호가 아닌 소괄호
		obArr[1] = new Person("choi", 22, 'M', 165,45);
		obArr[2] = new Person("yu",32,'M',173.2,72.3);
		
		// 	방법2 : 중괄호
		Person02[] obArrr000 = {new Person02(),
new Person02(),
new Person02()
								};
		
		
		// 	방법3 : for문
		Person02[] obArrr = new Person02[5];
		for(int i=0; i < obArrr.length; i++) {
			obArrr[i] = new Person02("a",1,'M',1,1);
			System.out.println(obArrr[i].personInfo()); // 객체값 출력
		}
		// 이중포문으로 객체 안 숫자 증가시켜보기
		for(int i=0; i < obArrr.length;i+=2) {
			int j=1;
			for(; j < obArrr.length; j++) {
				obArrr[i] = new Person02("a",j,'M',j+10,j+20);
				System.out.println(obArrr[i].personInfo());
			}
		}
		
		// 객체 배열 : 출력
		// 
		for(int i=0; i < obArrr.length; i++) {
			obArrr[i] = new Person02();
			System.out.println(obArrr[i] + " ");		// 주소값 출력
			System.out.println(obArrr[i].personInfo()); // 객체값 출력
		}
		
		System.out.println("====null====");
		System.out.println(Arrays.toString(obArrr)); // [chap06_objectArray.model.vo.Person02@6d06d69c, chap06_objectArray.model.vo.Person02@7852e922, chap06_objectArray.model.vo.Person02@4e25154f, chap06_objectArray.model.vo.Person02@70dea4e, chap06_objectArray.model.vo.Person02@5c647e05]
		System.out.println(obArrr[0].personInfo());  // null, 0,  0.0, 0.0
		obArrr = null;
		System.out.println(Arrays.toString(obArrr)); // null
		
		Person02[] objArr001;
		Person02[] objArr002 = new Person02[5];
		objArr002[0] = new Person02("a", 1,'M',171,66.2);
		objArr002[1] = new Person02();
		objArr002[2] = new Person02();
//		objArr002[2] = new Person02(Person02.getName()); // Person02클래스의 게터에서 값을 끌어올 수 있을까 해서 해봄 
		// 스태틱 요구함 Cannot make a static reference to the non-static method getName() from the type Person02
		Person02[] objArr004 = {new Person02(),
								new Person02("철희", 32, 'M', 171,56),
								new Person02("영희", 32, 'W', 161,46)
								};

		Person02[] objArr003 = new Person02[5];
		for(int i=0; i < objArr003.length; i++) {
			objArr003[i] = new Person02(); 
			System.out.println(objArr003[i].personInfo());
		}
		
	

	}

배열에 객체가 들어가다보니 기존 배열보다 좀 까다롭다는 느낌이 들었다

배열 안에 있는 객체 속성값에 접근해서 출력하는게 기존과는 달라서 좀 헤맸다는 것

기존 기본형 자료타입들과 다르게 객체타입이다보니 헷갈리는게 많았다는 것

아직은 숙련도가 많이 부족해서 계속 반복해서 내 손발처럼 될 수 있게 연습해야겠다

package chap06_objectArray.controller;

import java.util.Arrays;

import chap06_objectArray.model.vo.Person;

public class Person02Controller {
	
	public void objectArr00() {
		
		// 예제
		// 출처 :http://daplus.net/java-java%EB%A1%9C-%EA%B0%9D%EC%B2%B4-%EB%B0%B0%EC%97%B4-%EB%A7%8C%EB%93%A4%EA%B8%B0/
		
		// 1.선언 및 인스턴스화
		A[ ] arr = new A[4];
		
		// 2.객체 초기화
		// 방법1
		arr[0] = new A();
		arr[1] = new A();
		arr[2] = new A();
		arr[3] = new A();
		
		// 방법2
		for( int i=0; i<4; i++ ) {
			  arr[i] = new A();
		}
		// 방금 만든 객체에서 기존 메소드 호출 가능해짐
		// 방법1
		int x = arr[1].getNumber();
		// 방법2
		arr[1].setNumber(x);
		
	}
	
	public void objectArr01() {
		
		// 객체배열
		//
		// 배열 선언 : Stack 영역에 공간 생성(변수의 선언 : stack에 공간 차지)
		// 배열 할당 : heap 영역에 공간 생성
		// 배열 초기화 : 인덱스,중괄호,for문
		// 배열 삭제 : null
		// 배열 값 출력하는 방법 2가지 : for문 + vo클래스 toString메소드
		
		
		
		
		// 배열 선언 - stack 영역에 생성
		String objArr;
		
		// 배열 할당 - heap 영역에 생성
		Person[] objArr01 = new Person[3];
		
		// 초기화
		//	1)인덱스
		objArr01[0] = new Person();
		objArr01[1] = new Person("김철수", 20, 'M', 170.5, 70);
		objArr01[2] = new Person("이순신", 40,'M', 180.5, 85.5); 

// vo Person		
//		private String name;
//		private int age;
//		private char gender;
//		private double height;
//		private double weight;
		
		// 	2) 중괄호
		Person objArr02 = new Person("안중근", 30,'M', 175.5, 75.3);
		Person[] objArr03 = {new Person("유관순", 18,'F', 160.2, 45.5),
							 new Person("신사임당", 40,'F', 157.5, 43.2),
							 new Person("세종대왕", 55, 'M', 180.5, 80.5)
							};
		System.out.println(objArr02); // chap06_objectArray.model.vo.Person@6d06d69c
		System.out.println(Arrays.toString(objArr03)); // 객체주소값 출력 : [chap06_objectArray.model.vo.Person@6d06d69c, chap06_objectArray.model.vo.Person@7852e922, chap06_objectArray.model.vo.Person@4e25154f]

//		System.out.println(Arrays.toString(objArr02[0])); // The type of the expression must be an array type but it resolved to Person
//		for(int i=0; i < objArr02.length; i++) { // 
//			System.out.println(objArr02[i]);	// The type of the expression must be an array type but it resolved to Person
//		}										// for문 출력은 int나 int로 자동형변환되는 소수들이 가능
		
		
		// 	3) for문
		Person[] objArr04 = new Person[3];
		for(int i=0; i < objArr04.length; i++) {
			objArr04[i] = 
		}
		
		
		// 객체 주소값 출력
		for(int i=0; i < objArr03.length; i++) {
			System.out.println("objArr03 = "+objArr03[i]);
//				objArr03 = chap06_objectArray.model.vo.Person@7852e922
//				objArr03 = chap06_objectArray.model.vo.Person@4e25154f
//				objArr03 = chap06_objectArray.model.vo.Person@70dea4e
		}
		// vo클래스 toString()을 이용한 객체속성값 출력
		for(int i=0; i < objArr03.length; i++) {
			System.out.println(objArr03[i].personInfo());
//				유관순, 18, F, 160.2, 45.5
//				신사임당, 40, F, 157.5, 43.2
//				세종대왕, 55, M, 180.5, 80.5
		}
//		System.out.println(Arrays.toString(objArr03.personInfo())); // Cannot invoke personInfo() on the array type Person[]
//		System.out.println(Arrays.toString(objArr03[0].personInfo())); // The method toString(long[]) in the type Arrays is not applicable for the arguments (String)
//		System.out.println(Arrays.personInfo()); // toString빼고 바로 출력할려했으나 에러 : The method personInfo() is undefined for the type Arrays
		
		// 삭제
		objArr03 = null;
		System.out.println(objArr03); // null
		System.out.println(Arrays.toString(objArr03)); // null
		for(int i=0; i < objArr03.length; i++) {
			System.out.println(objArr03[i].personInfo()); // Exception in thread "main" java.lang.NullPointerException
		}
		
		
	}
	
	
	
}

객체 배열

객체를 담는 배열

배열의 자료형을 클래스명(사용자 정의 자료형)으로 지정하여 활용

선언

자료형[] 배열명;

자료형 배열명[];

클래스명[] 배열명;

클래스명 배열명[];

할당

배열명 = new 자료형[길이];

배열명 = new 클래스명[길이]

자료형[] 배열명 = new 자료형[길이];

클래스명[] 배열명 = new 클래스명[길이];

초기화

배열명[인덱스] = 값;

배열명[인덱스] = new 클래스명();

iArr[0] = 10;

tArr[0] new Trainee();

iArr = {1,2,3};

tArr = {new Trainee(),new Trainee()};

선언과 동시에 할당 및 초기화

클래스명 배열명[] = {new 클래스명(), new 클래스명()};

객체 배열의 메모리 작동

선언된 변수명이 stack에서 공간이 만들어지고, 거기서 할당되면서 heap에서 공간이 생성되는데

이때,  배열 하나의 주소 안에서 배열의 각 인덱스번호 별로 주소가 다시 나눠지는 구조

얕은 복사(shallow copy) & 깊은 복사(deep copy) 개념

https://rise-up.tistory.com/640

package confidence;

import java.util.Arrays;

public class D_array {

	public void shallowCopy() {

		int[] baseArr = {1,2,3,4,5};
		int[] copyArr = baseArr;

		System.out.println(baseArr); // [I@677327b6
		System.out.println(copyArr); // [I@677327b6
		
		// 원본 배열값 변경 후 주소값 확인해보기
		baseArr[4] = 10;
		for(int i=0; i<baseArr.length;i++) {
			System.out.print(baseArr[i] + " "); // 1 2 3 4 10
		}
		System.out.println();
		System.out.println(baseArr); // [I@677327b6
		System.out.println(copyArr); // [I@677327b6
		
		// 배열 값 출력하는 방법
		//  1)for문
		//  2)Arrays.toString()
		
		// 1)for문
//		int[] baseArr = {1,2,3,4,5};
//		for(int i=0; i<baseArr.length;i++) {
//			System.out.print(baseArr[i] + " "); // 1 2 3 4 5
//		}
		//  2)Arrays.toString()
		System.out.println(Arrays.toString(baseArr)); // [1, 2, 3, 4, 10]
		
		
		
	}
	
}

배열의 변수명을 그냥 print찍으면 아래처럼 주소값이 나온다

배열 안에 값을 어떻게 하면 볼 수 있을까?

배열 값, 출력하는 방법

1)for문

int[] baseArr = {1,2,3,4,5};

for(int i=0; i<baseArr.length;i++) {
	System.out.print(baseArr[i] + " ");       // 1 2 3 4 5
}

2)Arrays.toString()

java.util.Arrays의 toString() 메소드 : Arrays.toString()

int[] baseArr = {1,2,3,4,5};
System.out.println(Arrays.toString(baseArr)); // [1, 2, 3, 4, 5]

두 방법의 출력 방식이 다르다

for문은 1 2 3 4 5 하나씩 값이 찍히고

Arrays.toString()은 하나의 배열로 배열 자체 전체 값이 찍힌다

필요한 데이터 형태에 따라 골라쓰면 될 듯 하다

하나의 값만 저장하는 공간인 변수는 하나만 저장이 가능하기에 배열이 만들어짐

배열이란?

같은 자료형의 데이터의 여러개의 값을 저장할 수 있는 공간

배열 선언

자료형[] 배열명; // 자바식. 대부분 이쪽 사용
자료형 배열명[]; // C언어식.

int[] arr;

배열은 선언만해서는 쓸 수 없고 할당까지 해야함

배열은 기본자료형이 아니며 참조자료형처럼 사용

구조가 참조자료형처럼 되어있어 주소값을 갖는다

기본형, 참조형 구분 기준 : call by value & call by reference

즉, 주소값을 가져오느냐 값 자체를 그대로 복사해서 가져오느냐

* Stack 영역에 공간 생성

배열 할당

heap 메모리 영역에 공간을 생성하는 것

(변수의 선언 : stack에 공간 차지)

자료형[] 배열명 = new 배열명[배열길이]
자료형 배열명[] = new 자료형[배열길이]

메모리 영역에 공간을 생성해주는 역할을 new 연산자가 실행

new 연산자가 배열 할당하는 역할+heap영역에 생성된 공간에 대한 주소값을 발생시킴

배열의 크기 변경 가능할까?

배열은 크기 변경 불가

새로운 배열을 만들고 바꿔치기하거라 주소값이 바뀐다(0x100→0x200)

System.out.print("새로 할당할 배열의 길이 입력 : ");
		int size = sc.nextInt();
		
		double[] dArr = new double[size];
		System.out.println("dArr의 길이 : "+dArr.length);
		System.out.println("dArr의 주소값 : "+ dArr); // [D@74a14482
		
		dArr = new double[5];
		System.out.println("변경 후 dArr의 길이 : " + dArr.length);// 배열 길이 변경 가능
		System.out.println("변경 후 dArr의 주소값 : " + dArr);		 // but 길이 변경 후 주소값 달라짐 [D@1540e19d
		System.out.println();								 // 
		// 주소값하면 new 연산자가 떠올라야. 
		// dArr[30]에서 new연산자가 쓰이면서 새로운 공간생성과 함께 주소값 생성하기에 주소값이 달라짐

그래서 주소값이 바뀌는 것(0x100→0x200)

기존 배열 유지x

new연산자에 의해 heap영역에 새로운 배열의 공간이 생성되고 그에 따라 stack에 있는 변수명 dArr의 참조 변수값(주소값)도 0x100→0x200 바뀜

new 연산자 역할

1)배열 할당 : heap 메모리 영역에 공간 생성

2)heap 영역에 생성된 공간에 대한 주소값 생성

-배열 한칸이 아닌 배열 한덩이 전체에 대한 주소값

ex)주소값 0x100

heap이 컴퓨터와 사용자가 같이 사용하는 공간인 것

배열명에 담긴게 heap메모리 영역에 생성된 주소값을 담은 것

주소를 통해서 실제 데이터를 가리키는 것이다.

배열 초기화

1)인덱스 이용

1. 중괄호{}를 이용
2. for문 이용

1)인덱스 이용

배열명[인덱스] 값;
ex) 
int[] iArr = new int[3];
iArr[0] = 1;
iArr[1] = 2;
iArr[2] = 3;
iArr[3] = 4; // error : 배열이 3칸 할당됬는데 없는 4칸째에 값을 할당하려해서 

2) 중괄호{} 이용

자료형[] 배열명 = {값,값};
ex)
int[] arr = {1,2,3,4}; // 값 수에 따라 알아서 배열 칸 지정하고 생성함

3) for문 이용

내가 초기화할 값에 ‘규칙’이 존재할 경우 사용가능

for문 인덱스 이용한거라 int만 가능

for(int i=0; i<str.length; i++) {   
    arr[i] = i + 1;
}

배열 삭제

null 상태로 만드는게 삭제

**dArr = null;**

null을 넣으면 0x100→0x200 바뀐주소가 null로 바뀌면서 0x200과 연결이 끊어지면서 0x200의 데이터는사리지고 사실상 삭제 효과가 나타난다

배열 선언 
배열 할당
배열 초기화 : 인덱스,중괄호,for문
배열 삭제 : null
배열 값 출력하는 방법 2가지 : for문, Arrays.toString()
배열 복사 : shallow copy & deep copy

코드 익히기 & 배운 것들

배열 크기 변경 불가(삭제하고 새로 만들기에 주소값이 변경됨)
배열 안 값이 최대길이보다 짧으면 값만큼만 출력되서 나옴(여분공간에 다른값x)
dArr[3] = 3; // 3.0으로 출력 -> 자동형변환(int to double) 
초기화 for문 방법은 int만 가능하나, 실수로 형변환 가능한 int면 for문 가능 -> int인 i가 실수로 변환 가능한 수이기에 

public void arrayPractice() {
    // 배열 선언 
    // 배열 할당
    // 배열 초기화 : 인덱스,중괄호,for문
    // 배열 삭제 : null
    // 배열 값 출력하는 방법 2가지 : for문, Arrays.toString()
    // 배열 복사 : shallow copy & deep copy
    //
    // 		배열 크기 변경 불가(삭제하고 새로 만들기에 주소값이 변경됨)
    //		배열 안 값이 최대길이보다 짧으면 값만큼만 출력되서 나옴(여분공간에 다른값x)
    //		dArr[3] = 3;	// 3.0으로 출력 -> 자동형변환(int to double) 
    // 		초기화 for문 방법은 int만 가능하나, 실수로 형변환 가능한 int면 for문 가능 -> int인 i가 실수로 변환 가능한 수이기에 
    // 		null인 배열값 확인 시, for문방법은 널포인트익셉션 쓰므로 Arrays.toString() 사용해야함

    //배열 선언
    String[] arr; // Stack 영역에 공간 생성

    //배열 할당
    String[] sArr1 = new String[3];
    String sArr2[] = new String[3];

    // 배열 초기화
    // 방법1 : 인덱스
    sArr1[0] = "a";
    sArr1[1] = "b";
    sArr1[2] = "c";

    // 방법2 : 중괄호 {} 이용
    // 선언과 동시에 초기화
//		sArr2 = {"a","b","c"}; // error : 중괄호 타입은 자료형부터 풀로 적어주는 형태에만 가능
    String[] sArr3 = {"a","b","c"};

    // 방법3 : for문
    // 배열이 int타입인 경우만 사용가능
    // 		double로 형변환 가능한 int면 for문 가능할까?  
    // 		가능. int인 i가 실수로 변환 가능한 수이기에
    int[] intArr = new int[5];
    for(int i=0; i < intArr.length;i++) {
        intArr[i] = i + 1;
    }
    for(int i=0; i < intArr.length; i++) {
        System.out.print(intArr[i]+" "); 	// 1 2 3 4 5
    }

    // 배열 삭제
    intArr = null;
    System.out.println(Arrays.toString(intArr)); // null

    // 배열 값 출력하는 방법
    //  1)for문
    //  2)Arrays.toString()

    // 1)for문
//		int[] baseArr = {1,2,3,4,5};
//		for(int i=0; i<baseArr.length;i++) {
//			System.out.print(baseArr[i] + " "); // 1 2 3 4 5
//		}
    //  2)Arrays.toString()
//		System.out.println(Arrays.toString(baseArr)); // [1, 2, 3, 4, 10]


/******************************practice 2nd ************************************/

    // 배열 선언
    char[] cArr;

    // 배열 할당
    char[] cArr1 = new char[3];
    char[] cArr2 = new char[3];

    // 배열 초기화(추가)
    // 방법1 : 인덱스
    cArr1[0] = 'a';
    cArr1[1] = 'b';
    cArr1[2] = 'c';
//		cArr1[3] = 'd';
//		System.out.println(Arrays.toString(cArr1));
    // 방법2 : 중괄호
    char[] cArr11 = {'a','b','c'};
    char[] cArr22 = {'ㄱ','ㄴ','다'};
    char[] cArr3 = {'a','b','c'};
    // 방법3 : for문
    // int배열만 사용가능
//		char[] cArr4 = new char[4];
//		for(int i=0; i < cArr4.length; i++) {
//			cArr4[i] = i + 1; // int배열만 사용가능하기에 error : Type mismatch: cannot convert from int to char
//			System.out.print(cArr4[i] + " ");
//		}

    int[] cArr4 = new int[4];
    for(int i=0; i < cArr4.length; i++) {
        cArr4[i] = i + 1;
        System.out.print(Arrays.toString(cArr4)+'\n'); // [1, 0, 0, 0][1, 2, 0, 0][1, 2, 3, 0][1, 2, 3, 4]
    }
    System.out.println(Arrays.toString(cArr4)); // [1, 2, 3, 4]

    // 배열 삭제
    cArr4 = null; 
    System.out.println(Arrays.toString(cArr4));
    System.out.println(Arrays.toString(cArr3));
    cArr3 = null;
    System.out.println(Arrays.toString(cArr3));


System.out.println("===practice 3rd===");		


/******************************practice 3rd ************************************/
    // 배열 선언
    float[] fArr;
    float[] floatArr;	// Stack 영역에 공간 생성

    // 배열 할당
    float[] fArr1 = new float[5];
    double[] dArr = new double[5];

    // 배열 초기화
    // 방법 1 : 인덱스
    dArr[0] = 0.1;
    dArr[1] = 0.2;
    dArr[2] = 3.0;
    dArr[3] = 3;	// 3.0으로 출력 -> 자동형변환
    System.out.println(Arrays.toString(dArr));

    // 방법2 : 중괄호
    double[] dArr2 = {0.1,0.2,0.3};
    System.out.println(Arrays.toString(dArr2)); // [0.1, 0.2, 0.3] -> 배열 안 값이 최대길이보다 짧으면 값만큼만 출력되서 나옴(여분공간에 다른값x)
    // 방법3 : for문
    double[] dArr3 = new double[3];
    // double로 형변환 가능한 int면 for문 가능할까?  
    // 가능. int인 i가 실수로 변환 가능한 수이기에
    for(int i=0; i < dArr3.length; i++) {
        dArr3[i] = i + 1;
        System.out.print(dArr3[i]+" "); // 1.0 2.0 3.0 
    }
    System.out.println();


    dArr3 = null;
//		for(int i = 0; i < dArr3.length; i++) {
//			System.out.println(dArr3); // null인 배열값 확인 시, for문방법은 널포인트익셉션 쓰므로 Arrays.toString() 사용해야함
//		}
    System.out.println(Arrays.toString(dArr3)); // null


}

배열의 메소드

indexOf()

해당 요소가 위치한 인덱스 번호 반환

없으면 -1반환

concat()

이어 붙이기

join()

결합해서 ‘문자열’로 반환

join()은 parameter 지정안

reverse()

배열의 값을 뒤집어서 반환

sort()

배열 값을 정렬 : 안에 들어온 값들을 문자열로 변환해서 문자열 정렬

push() & pop()

push : 마지막에 요소 추가 pop : 마지막 요소 꺼내오기(꺼내오며 마지막 요소가 배열에서 삭제됨)

<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">

<title>Document</title>

</head>
<body>
    
    <script>
        // 배열의 메소드
        
        
        var a = ['a','b','c','4',5];
        console.log(typeof a); // object
        
        // indexOf()
        console.log(a.indexOf('a')); // 0 
        console.log(a.indexOf());    // 없으면 -1 반환
        
        // concat() 이어붙이기
        console.log(a.concat(6));    //  (6) ['a','b','c','4',5,6] 6추가됨
        
        // join
        console.log(a.join());      // a,b,c,4,5  
        console.log(typeof a.join());    //  str
        console.log(a.join("|"));    //  a|b|c|4|5
        console.log(a.join("a","q"));    //  aabaca4a5a


        // reverse
        console.log(a.reverse());    //  (5) [5, '4', 'c', 'b', 'a']
        
        // sort
        console.log(a.sort());    //  ['4', 5, 'a', 'b', 'c']


        // push : 마지막 요소에 추가
        console.log(a);           // (5) ['4', 5, 'a', 'b', 'c']
        console.log(a.push());    //  5     <- 콘솔에서는 소트된 상태에서 원래 배열의 마지막값 5를 반환
        console.log(a.push(6));    //  6    
        console.log(a);           // (6) ['4', 5, 'a', 'b', 'c',6]
        console.log(a.push())       // 6 // 파라미터 안적으면 배열의 길이 반환(?)
        console.log(typeof(a.push()));    //  number

        //pop
        console.log(a.pop());    //  6
        console.log(a);    //  (5) ['4', 5, 'a', 'b', 'c'] <- 6삭제됨
        console.log(a.pop(0));      // c
        console.log(a.pop("0"));    // b    매개변수를 넣어도 마지막요소 빼오고 삭제
        console.log(a);    //  (3) ['4', 5, 'a']  


       
    </script>


</body>
</html>

배열 복사 - deep copy - System.arraycopy()

System.arraycopy()

System.arraycopy(src, srcPos, dest, destPos, length)

src : 원본 배열
srcPos : 포지션. 원본배열에서 복사를 시작할 위치
dest : 복사 배열
destpos: 복사 배열에서 붙여놓기를 시작할 위치
length : 얼만큼 복사를 해올지에 대한 복사 길이

		int[] sourceArr = {10,20,30};
		int[] copyArr = new int[6];
        
        System.arraycopy(sourcArr, 0 , copyArr, 0, 3);

배열길이 자동 수정x

복사된 값의 나머지 공간은 해당 배열의 데이터 타입의 기본값으로 채워진다

ex)

int 배열값을 복사하고 나머지 공간은 0으로 채워진다
double 배열값을 복사하고 나머지 공간은 0.0
char 배열값을 복사하고 나머지 공간은 공백
String 배열값을 복사하고 나머지 공간은 null

// 방법2:System.array.copy()
		// 배열길이 자동 수정x
		// int 배열값을 복사하고 나머지 공간은 0으로 채워진다
		// double 배열값을 복사하고 나머지 공간은 0.0
		// char 배열값을 복사하고 나머지 공간은 공백
		// String 배열값ㅇ르 복사하고 나머지 공간은 null
		//
		// System.arraycopy(src, srcPos, dest, destPos, length)
		// src : 원본 배열
		// srcPos : 포지션. 원본배열에서 복사를 시작할 위치
		// dest : 복사 배열
		// destpos: 복사 배열에서 붙여놓기를 시작할 위치
		// length : 얼만큼 복사를 해올지에 대한 복사 길이
		
		
		int[] sourceArr3 = {10,20,30};
		int[] cloneArr3 = new int[3];
		 
		System.arraycopy(sourceArr3, 0, cloneArr3, 0, cloneArr3.length);
		System.out.println(sourceArr3);
		for(int i=0;i<sourceArr3.length;i++) {
			System.out.print(sourceArr3[i]+" "); // 10 20 30
		} 										 // 원본 값
		System.out.println();
		for(int i=0;i<cloneArr3.length;i++) {
			System.out.print(cloneArr3[i]+" ");  // 10 20 30
		} 										 // 클론 값
		System.out.println();
		
		int[] sourceArr4 = {10,20,30,40,50};
		int[] cloneArr4 = new int[3];
		 
		System.arraycopy(sourceArr4, 0, cloneArr4, 0, cloneArr4.length);
		// 원본 인덱스0번부터4번까지 배열값 복사해서 복제본의 0번째 인덱스부터 붙여넣는다는 의미
		for(int i=0;i<sourceArr4.length;i++) {
			System.out.print(sourceArr4[i]+" ");// 10 20 30 40 50
		} 										// 원본값
		System.out.println();
		for(int i=0;i<cloneArr4.length;i++) {
			System.out.print(cloneArr4[i]+" "); // 10 20 30
		} 										// 클론값
		// 
		System.out.println();
		
		System.arraycopy(sourceArr4, 2, cloneArr4, 0, cloneArr4.length);
		// 원본 인덱스2번부터4번까지 30 40 50의 배열값 복사해서 복제본의 0번째 인덱스부터 붙여넣는다는 의미
		for(int i=0;i<sourceArr4.length;i++) {
			System.out.print(sourceArr4[i]+" ");// 10 20 30 40 50
		} 										// 원본값
		System.out.println();
		for(int i=0;i<cloneArr4.length;i++) {
			System.out.print(cloneArr4[i]+" "); // 30 40 50 
		} 										// 클론값
		// 
		System.out.println();
		
		
		
		int[] a = {2,4,6,8,10};
		int[] b = new int [10];
		
		System.arraycopy(a, 3, b, 0, 2);
		// dest의 범위가 0-5까지는 잘나오고 6부터 error
		for(int i=0; i<a.length;i++) {
			System.out.print(a[i]+" "); // 2 4 6 8 10 
		}								// 원본값
		System.out.println();
		for(int i=0; i<b.length;i++) {
			System.out.print(b[i]+" "); // 8 10 0 0 0 0 0 0 0 0 
		}								// 카피값
		System.out.println();
		
		// int 배열
		int[] src = {3,6,9,12};
		int[] clone = new int[8];
		
		System.arraycopy(src, 2, clone, 6, 2);
		// src 2번인덱스부터 길이2를 복사해서 9,12값을 clone의 6번째부터 복사
		for(int i=0; i<src.length;i++) {
			System.out.print(src[i]+" "); // 3 6 9 12 
		}								  // 원본값
		System.out.println();
		for(int i=0; i<clone.length;i++) {
			System.out.print(clone[i]+" ");// 0 0 0 0 0 0 9 12 
		}								   // 카피값
		System.out.println();
		
		int[] src2 = {3,6,9,12};
		int[] clone2 = new int[8];
		System.arraycopy(src2, 2, clone2, 5, 2);
		for(int i=0; i<clone2.length;i++) {
			System.out.print(clone2[i]+" ");// 0 0 0 0 0 9 12 0  
		} // 복사되고 int배열의 공백은 0으로 채워진다       // 카피값
		System.out.println();
		
		
		// double 배열
		double[] dSrc = {1.0,1.5,2.0,2.5};
		double[] dCopy = new double[8];
		
		System.arraycopy(dSrc, 0, dCopy, 4, dSrc.length);
		for(int i=0;i<dCopy.length;i++) {
			System.out.print(dCopy[i]+" ");//0.0 0.0 0.0 0.0 1.0 1.5 2.0 2.5  
		}								   // 복사된 값 외에 나머지 공간 : 0.0
		System.out.println();
		
		// char 배열
		char[] cSrc = {'a','b','c'};
		char[] cCopy = new char[6];
		
		System.arraycopy(cSrc, 0, cCopy, 0, cSrc.length);
		for(int i=0;i<cCopy.length;i++) {
			System.out.print(cCopy[i]+" ");//a b c (공백)
		}								   // // 복사된 값 외에 나머지 공간 : 공백
		System.out.println();
		
		// String 배열
		String[] sSrc = {"A","B","C"};
		String[] sCopy = new String[6];
		
		System.arraycopy(sSrc, 0, sCopy, 0, sSrc.length);
		for(int i=0;i<sCopy.length;i++) {
			System.out.print(sCopy[i]+" ");// A B C null null null 
		}								   // 복사된 값 외에 나머지 공간 : null
		System.out.println();