Day7

Java의 배열
배열 : 같은 타입의 데이터를 연속된 공간에 나열시키고, 각 데이터에 인덱스를 부여해놓은 자료 구조

특징
1. 인덱스를 통해 배열의 값에 접근할 수 있다. ex. scores[0]
2. 같은 타입의 데이터만 저장할 수 있다. ex. int[], double[]
3. 한번 생성되고 나면 배열의 길이를 늘리거나 줄일 수 없다. (배열의 길이를 늘리려면, 더 큰 배열을 만든 후에 기존의 배열을 복사해넣어야한다.)
4. 데이터 타입에 따른 기본값

분류	데이터 타입	초기값
기본 타입(정수)	byte[]	0
	char[]	'\u0000'
	short[]	0
	int[]	0
	long[]	0L
기본 타입(실수)	float[]	0.0F
	double[]	0/0
기본 타입(논리)	boolean[]	false
참조 타입 (String도 여기 해당)	클래스[]	null
	인터페이스[]	null

---

• 배열도 객체이므로 힙 영역에 생성, 참조할 배열 객체가 없다면 null 값으로 초기화할 수 있다.
• 배열 변수가 null값을 가진 상태에서 항목에 접근 불가능
• 배열이 생성된 이후에는 대입연산자를 통해 값을 저장할 수 있다
• 메소드의 매개값이 배열일 경우에도 new연산자와 함께 사용해주어야 한다
• 배열의 인덱스 범위를 넘은 값으로 접근하려고 하면 오류 발생

---

Java에서의 배열 선언

int[] test; // 타입[] 변수
int test[]; // 타입 변수[]

배열 선언 후 초기화 케이스

// 1.
int[] intArr2 = {10, 20, 30};

// 2.
int[] intArr2; // 선언
intArr2 = new int[]{10,20,30}; // new연산자와 함께 초기화

intArr2 = {10,20,30}; // 오류 발생

// 3.
int[] intArr2 = null; // null값으로 초기화
intArr2 = new int[3]; // 공간 3개
intArr2[0] = 10;
intArr2[1] = 20;
intArr2[2] = 30; // 각 인덱스에 값 저장 (반복문으로도 가능)

배열의 길이 얻어오는 법 -> 배열.length
readOnly 필드이기 때문에 대입연산자를 통해 값을 바꿀 수 없다.

다차원 배열

int[][] scores = new int[2][3]; // new 타입[행][열]

scores[0] = new int[]{10, 20, 30};
scores[1] = new int[]{40, 50, 60};

						
for (int i = 0; i <scores.length; i++) {
	for (int k =0; k< scores[i].length; k++) {
		System.out.print("(" + i + "," + k + ")= " + scores[i][k] + " ");
	}
	System.out.println();
}

// 결과
(0,0) = 10 (0,1) = 20 (0,2) = 30 
(1,0) = 40 (1,1) = 50 (1,2) = 60 

2행 3열을 가진 다차원 배열

다차원 배열은 수학 행렬구조 뿐만 아니라 계단식 구조도 가질 수 있다.

int[][] scores = new int[2][];
scores[0] = new int[2];
scores[1] = new int[3];

for (int i = 0; i <scores.length; i++) {
	for (int k =0; k< scores[i].length; k++) {
		System.out.print("(" + i + "," + k + ")= " + scores[i][k] + " ");
	}
	System.out.println();
}

// 결과
(0,0) = 0 (0,1) = 0 
(1,0) = 0 (1,1) = 0 (1,2) = 0 

객체를 참조하는 배열

• 참조타입 배열은 각 항목에 객체의 주소를 가지고 있다
• 따라서 참조타입 배열도 참조타입 변수와 동일하게 취급되어야 한다.

String[] strArray = new String[3];
strArray[0] = "안녕";
strArray[1] = "안녕";
strArray[2] = new String("안녕"); // 새로운 객체 주소 저장

System.out.println(strArray[0] == strArray[1]); // 같은 객체 주소 참조
System.out.println(strArray[1] == strArray[2]); // 다른 객체 주소 참조 

System.out.println(strArray[0].equals(strArray[1])); // 문자열 값만 비교 
System.out.println(strArray[0].equals(strArray[2])); // 문자열 값만 비교

// 결과
true
false
true
true

배열 복사 방법
1. 더 큰 공간을 가진 배열 생성, 그 안에 복사하기
2. System.arraycopy 메소드 사용하기 : System.arraycopy(원본 배열, 시작 인덱스, 새 배열, 새 시작 인덱스, 복사할 길이)

int[] smallArr = {1, 2, 3};
int[] bigArr = new int[6]; // 공간 6개 

// 1.
for (int j = 0; j<smallArr.length; j++) {
	bigArr[j] = smallArr[j];
	System.out.print(bigArr[j] + " ");
}

// 결과
1 2 3 0 0 0



// 2. arraycopy 사용하기
System.arraycopy(smallArr, 0, bigArr, 2, smallArr.length);
for (int j = 0; j<bigArr.length; j++) {
	System.out.print(bigArr[j] + " ");
}

// 결과 
0 0 1 2 3 0 

향상된 for문
장점 : 간편하다, 카운터 변수, 증감식 사용하지 않아도 반복 가능
단점 : 뒤에서부터 출력하거나, 중간값에 접근하기가 어렵다

int[] nums = {10, 20, 30, 40, 50};
for(int num : nums) { // 배열의 개수만큼 반복하고 종료됨
	System.out.println(num);
}

// 결과
10 20 30 40 50

---

다차원 배열에서의 값 출력
ex.
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

1. 변수 선언해서 누적된 값을 출력하기

int[][] initialArr = new int[4][4]; // 4x4 배열 초기화

int num = 1;
for (int i = 0; i < initialArr.length; i++) { // 행 4줄 만드는 반복문
	for (int j = 0; j < initialArr[i].length; j++) { // 하나의 행 안에서 연속되는 숫자 출력하는 반복문
   		System.out.print(num + " ");
   		num++;
    }
   System.out.println(); // 반복문 한번 돌고 엔터
}

2. 각 열의 규칙 찾아서 출력하기

각 행의 인덱스 0 값 = 1 5 9 13 (17, 21, 25...)
=> 4x0 + 1, 4x1 + 1, 4x2 + 1... 4*k + 1

각 행의 인덱스 1 값 = 2 6 10 14 (18 22, 26...)
=> 4x0 + 2, 4x1 + 2, 4x2 + 2 ... 4*k + 2

각 행의 인덱스 2 값 = 3 7 11 15 (19, 23, 27...)
=> 4x0 + 3, 4x1 + 3, 4x2 + 3 ... 4*k + 3

각 행의 인덱스 3 값 = 4 8 12 16 (20, 24, 28...)
=> 4x0 + 4, 4x1 + 4, 4x2 + 4 ... 4*k + 4

int[][] initialArr = new int[4][4]; // 4x4 배열 초기화

for (int i = 0; i < initialArr.length; i++) { // 행 4줄 만드는 반복문
	
    for (int j = 0; j < initialArr[i].length; j++) { // 하나의 행 안에서 연속되는 숫자 출력하는 반복문
		initialArr[i][j] = (4*i)+(j+1); // j가 0부터 시작하기 때문에
    	System.out.print(initialArr[i][j] + " ");
    }
  
  System.out.println(); // 반복문 한번 돌고 엔터
}

---

ex.
1 2 3 4 5
10 9 8 7 6
11 12 13 14 15
20 19 18 17 16

1. 배열에 거꾸로 저장, 그대로 출력

int[][] test = new int[4][5];
int a = 1;

for (int i = 0; i<test.length; i++){
	if (i % 2 == 0) { // 짝수 줄
		for (int j = 0; j < test[i].length; j++) {
			test[i][j] = a;
			a++;
			System.out.print(test[i][j] + " ");	
		}
    // 짝수 줄은 순서대로 저장해서 순서대로 출력
	} else { // 홀수 줄
		for (int j = test[i].length-1; j>=0; j--) {
    	// 거꾸로 저장 (인덱스 네번째 부터)
			test[i][j] = a;
			a++;
		}
        
		for (int k = 0; k < test[i].length; k++) {
        // 거꾸로 저장했기 때문에 출력은 그대로
			System.out.print(test[i][k] + " ");
		}
	}
	System.out.println();
}
					

2. 배열에 그대로 저장, 거꾸로 출력

int[][] test = new int[4][5];
int a = 1;

for (int i = 0; i<test.length; i++){
	if (i % 2 == 0) { // 짝수 줄
		for (int j = 0; j < test[i].length; j++) {
			test[i][j] = a;
			a++;
			System.out.print(test[i][j] + " ");	
		}
    // 짝수 줄은 순서대로 저장해서 순서대로 출력
	} else { // 홀수 줄
		for (int j = 0; j<test[i].length; j++) {
    	// 그대로 저장
			test[i][j] = a;
			a++;
		}
        
		for (int k = test[i].length-1; k>=0; k--) {
        // 그대로 저장했기 때문에 출력은 거꾸로
			System.out.print(test[i][k] + " ");
		}
	}
	System.out.println();
}