[28] 230207 Java Ch. 5 참조 타입: 2. 배열 [K-디지털 트레이닝 28일]

230207 Tue 28th class

Ch. 5 참조 타입
진도: p. 186 ~ (교재: 혼자 공부하는 자바, 저자: 신용권)

혼자 공부하는 자바

 

오늘 배운 것 중 기억할 것을 정리했다. 

---

지난 수업 때 배운 것 중 다시 기억할 것

System.out.println(); 엔터 효과가 있다. 

Continue: (//스킵) break문과 마찬가지로 continue문도 대개 if문과 같이 사용되는데, 
특정 조건을 만족하는 경우에 continue문을 실행해서 그 이후의 문장을 실행하지 않고 다음 반복으로 넘어간다.

2023.02.03 - [1. Revision 2023/Java] - [26] 230204 Ch. 4 자바 조건문과 반복문(2): 반복문: for문, while문, do-while문

boolean 타입의 배열 항목의  기본 초기값은 false이다.

---

Ch. 5 자바 참조 타입

책의 목차
05-1 참조 타입과 참조 변수
05-2 배열
05-3 열거 타입

5.2 배열 p. 177

1) 배열이란? p. 178

배열은 같은 타입의 데이터를 연속된 공간에 나열하고 각 데이터에 인덱스(index)를 부여해 놓은 자료구조이다. 
- 배열은 같은 타입의 데이터만 저장할 수 있다.
- 한 번 생성된 배열은 길이를 늘리거나 줄일 수 없다.

---

2) 배열 선언 p. 179

변수 선언
int 10;
int 20;
\초기화
a=100; b=20;

배열 선언
int[] score//타입[] 변수명
int score[]//타입 변수명[]

두 가지 형식으로 작성할 수 있다. 
타입[] 변수;
타입 변수[];

---

3) 배열 생성 p. 180

2.1) 값 목록으로 배열 생성 

타입[] 변수 = {값0, 값1, 값2, 값3, ...};
String[] names = {"신용권", "홍길동", "김자바"};

{값1, 값2, 값3, ... }처럼 값 목록으로 생성한다.
생성과 초기화 동시에 

예제) 값 목록으로 배열 생성

public class P180ArrayCreateByValueListExample {
	public static void main(String[] args) {
		int[] scores = {83, 90, 87};
		
		System.out.println("scores[0] : "+scores[0]);
		System.out.println("scores[1] : "+scores[1]);
		System.out.println("scores[2] : "+scores[2]);
		
		int sum = 0;
		for(int i=0; i<3; i++) {
			sum += scores[i];
		}
		System.out.println("총합 : "+sum);
		double avg = (double) sum/3;
		System.out.println("평균 : "+avg);
	}
}

결과)

scores[0] : 83
scores[1] : 90
scores[2] : 87
총합 : 260
평균 : 86.66666666666667

---

배열 변수를 이미 선언한 후에는 다른 실행문에서 중괄호를 사용한 배열 생성이 허용되지 않는다.

타입[] 변수;
int[] scores;
변수 = {값0, 값1, 값2, 값3, ...} //컴파일 에러

배열 변수를 미리 선언한 후 값 목록들이 나중에 결정되는 상황이라면 new 연산자를 사용해서 값 목록을 지정해 주면 된다.
new 연산자 바로 뒤에는 배열 변수 선언에서 사용한 "타입[]"을 붙여주고 중괄호 {}에는 값들을 나열한다.

변수 = new 타입[] {값0, 값1, 값2, 값3, ...};
scores = new int[] {83, 90, 87};

String[] names = null;
names = new String[] {"신용권", "홍길동", "김자바"}

int[] scores;
scores = new int[]{83, 90, 87};

 

메서드의 매개값이 배열일 경우도 마찬가지이다.
매개 변수로 int[] 배열이 선언된 add 메서드가 있을 경우, 값 목록으로 배열을 생성함과 동시에 add() 메서드의 매개값으로 사용하고자 할 때는 반드시 new 연산자를 사용해야 한다.

int add(int[] scores) {...}

int result = add({95, 85, 90});//컴파일 에러
int result = add(new int[] {95, 85, 90});

예제)

public class P182ArrayCreatByValueListExample2 {

	public static void main(String[] args) {
		int[] scores; //scores라는 배열을 선언한다. 
		scores = new int[] {83, 90, 87};
		int sum1 = 0;
		for (int i=0; i<3; i++) {
			sum1 += scores[i];
		}
		System.out.println("총합: " + sum1);
		
		int sum2 = add(new int[] {83, 90, 87});
		System.out.println("총합: " + sum2);
		System.out.println();
	}
	
	//총합을 계산해서 리턴하는 메서드이다. 
	public static int add(int[] scores) {
		int sum = 0;
		for (int i=0; i<3; i++) {
			sum += scores[i];
		}
		return sum;
	}
}

결과)

총합: 260
총합: 260

---

2.2) new 연산자로 배열생성

값의 목록을 가지고 있지 않지만, 향후 값들을 저장할 배열을 미리 만들고 싶다면 new 연산자로 배열 객체를 생성할 수 있다.

타입[] 변수 = new 타입[길이];

길이는 배열이 저장할 수 있는 값이 개수이다. 이미 배열 변수가 선언된 경우에도 new 연산자로 배열을 생성할 수 있다. 

타입[] 변수 = null;
변수 = new 타입[길이];

길이가 5인 int[] 배열을 생성한다.

int[] intArray = new int[5];

생성과 초기화 따로, 생성과 동시에 초기화

배열 scores의 0,1,2 인덱스에 각각 83, 90, 75를 저장하는 코드이다.

int[] scores = new int[3];
scores[0] = 83;
scores[1] = 90;
scores[2] = 75;

		0x100
arr1	0x100<---	0	0	0
		arr[0]	arr[1]	arr[2]

예제)

public class ArraryCreatByNewExample {
	public static void main(String[] args) {
		int[] arr1 = new int[3]; //3개의 값이 있다. 
		
		for(int i=0;i<3;i++) {
			System.out.println("arr1[" + i + "]: " + arr1[i]);
		} //0 0 0 
		
		arr1[0] = 10;
		arr1[1] = 20;
		arr1[2] = 30;
		for(int i=0; i<3; i++) {
			System.out.println("arr1[" + i + "]: " + arr1[i]);
		} //10 20 30
		
		double[] arr2 = new double[3];
		for(int i=0; i<3; i++) {
			System.out.println("arr2[" + i + "]: " + arr2[i]);
		} //0.0 0.0 0.0
		
		arr2[0] = 0.1;
		arr2[1] = 0.2;
		arr2[2] = 0.3;
		for(int i=0; i<3; i++) {
			System.out.println("arr2[" + i + "]: " + arr2[i]);
		} //0.1 0.2 0.3
		
		String[] arr3 = new String[3];
		for(int i=0; i<3; i++) {
			System.out.println("arr3[" + i + "]: " + arr3[i]);
		} //null null null
		
		arr3[0] = "1월";
		arr3[1] = "2월";
		arr3[2] = "3월";
		for(int i=0; i<3; i++) {
			System.out.println("arr3[" + i + "]: " + arr3[i]);
		} //1월 2월 3월
	}
}

결과)

arr1[0]: 0
arr1[1]: 0
arr1[2]: 0
arr1[0]: 10
arr1[1]: 20
arr1[2]: 30
arr2[0]: 0.0
arr2[1]: 0.0
arr2[2]: 0.0
arr2[0]: 0.1
arr2[1]: 0.2
arr2[2]: 0.3
arr3[0]: null
arr3[1]: null
arr3[2]: null
arr3[0]: 1월
arr3[1]: 2월
arr3[2]: 3월

---

4) 배열 길이 p. 185

배열에 저장될 수 있는 항목(값)의 수를 말한다. 배열의 length 필드에 저장되어 있기 때문에 변수.length로 배열 길이를 읽을 수 있다.

예시)

public class P186ArrayLengthTime {
	public static void main(String[] args) {
		int[] scores = {83, 90, 87};
		int sum = 0;
		for(int i = 0; i<scores.length; i++) {
			sum += scores[i];
		}
		System.out.println("총합: " + sum);
		
		double avg = (double) sum/scores.length;
		System.out.println("평균: " + avg);
	}
}

결과)

총합: 260
평균: 86.66666666666667

문제)

public class P187A {
	public static void main(String[] args) {
		/* 10, 20, 30, 50, 3, 60, -3 값을 배열에 지정하고 아래 문제를 풀어보세요.
		 * 문제1. arr 배열 중에서 인덱스가 1인 곳의 값을 출력해보자. 정답)20*/
		int[] arr = {10,20,30,50,3,60,-3};
		/*int[] arr = new int[7];
		 * arr[0]=10;
		 * arr[1]=20;
		 * arr[2]=30;
		 * arr[4]=50;
		 * arr[5]=3;
		 * arr[6]=60;
		 * arr[7]=-3;
		 */
		System.out.println(arr[1]);
		
		/*문제2. arr 배열 중에서 값이 60인 곳의 인덱스를 출력해보자. 정답)5*/
		for (int i=0;i<7;i++) {
			//arr 배열 값 중에서 60이면
		if (arr[i]==60) {
			System.out.println(i);
		}
	}
		/*문제3. arr 배열의 인덱스가 3인 곳은 출력하지 말고 나머지만 출력해보자.*/
		for(int i=0; i<7; i++) {
		if (i!=3) {
			System.out.print(arr[i]+",");
		}
	}
		System.out.println();
		/*문제3.(수업) arr 배열의 인덱스가 3인 곳은 출력하지 말고 나머지만 출력해보자.*/
		for(int i=0; i<7; i++) {
		if (i==3) {
			continue;
		}
		System.out.print(arr[i]+",");
	}	
}
}

정답) if (i==3){

20
5
10,20,30,3,60,-3,
10,20,30,3,60,-3,

---

A1)

		0x100
arr	0x100<---	arr	10	20	30	50	3	60	-3
			arr[0]	arr[1]	arr[2]	arr[3]	arr[4]	arr[5]	arr[6]

예제)

/* 10, 20, 30, 50, 3, 60, -3 값을 배열에 지정하고 아래 문제를 풀어보세요.
 * 문제1. arr 배열 중에서 인덱스가 1인 곳의 값을 출력해보자. 정답)20
 * 문제2. arr 배열 중에서 값이 60인 곳의 인덱스를 출력해보자. 정답)5
 * 문제3. arr 배열의 인덱스가 3인 곳은 출력하지 말고 나머지만 출력해보자.
 * 
 * 배열 문제와 별개로 구글에 최대값 최소값을 어떤 식으로 구하는지 알아보세요.
 */
public class P187A {
	public static void main(String[] args) {
		/* 10, 20, 30, 50, 3, 60, -3 값을 배열에 지정하고 아래 문제를 풀어보세요.
		 * 문제1. arr 배열 중에서 인덱스가 1인 곳의 값을 출력해보자. 정답)20*/
		int[] arr = {10,20,30,50,3,60,-3};
		/*int[] arr = new int[7];
		 * arr[0]=10;
		 * arr[1]=20;
		 * arr[2]=30;
		 * arr[4]=50;
		 * arr[5]=3;
		 * arr[6]=60;
		 * arr[7]=-3;
		 */
		System.out.println(arr[1]);
		
		/*문제2. arr 배열 중에서 값이 60인 곳의 인덱스를 출력해보자. 정답)5*/
		for (int i=0;i<7;i++) {
			//arr 배열 값 중에서 60이면
		if (arr[i]==60) {
			System.out.println(i);
		}
	}
		/*문제3. arr 배열의 인덱스가 3인 곳은 출력하지 말고 나머지만 출력해보자.*/
		for(int i=0; i<7; i++) {
		if (i!=3) {
			System.out.print(arr[i]+",");
		}
	}
		/*문제3.(수업중) arr 배열의 인덱스가 3인 곳은 출력하지 말고 나머지만 출력해보자.*/
		for(int i=0; i<7; i++) {
		if (i==3) {
			continue;//스킵
		}
		System.out.print(arr[i]+",");
	}	
}
}

결과) if (i==3){continue;}로도 가능하다. 
참고: https://dpdpwl.tistory.com/95

20
5
10,20,30,3,60,-3,10,20,30,3,60,-3,

---

5) 명령 라인 입력 p. 186

예제) main() 메서드의 매개 변수
실행할 때 2개의 문자열을 주지 않으면 "값의 수가 부족합니다."를 출력하고 강제 종료한다.
만약 2개의 문자열이 정확하게 입력되었다면 2개의 문자열을 정수로 변환하고 덧셈 연산을 수행한다.

	0x100	null "10" -> 10	"20"-> 20
args<---	args	args[0]	args[1]

public class P167MainStringArrayArgument {
	public static void main(String[] args) {
		if(args.length != 2) { //입력된 데이터의 수가 2개가 아닐 경우
			System.out.println("값의 수가 부족합니다.");
			System.exit(0); //프로그램 강제 종료
		}
		
		String strNum1 = args[0]; //첫 번째 데이터 얻기
		String strNum2 = args[1]; //두 번째 데이터 얻기
		
		int num1 = Integer.parseInt(strNum1); //문자열을 정수로 변환
		int num2 = Integer.parseInt(strNum2); //문자열을 정수로 변환

		int result = num1 + num2;
		System.out.println(num1 + "+" + num2 + "=" + result);
	}
}​

결과) Run - Run configurations - Arguments에서 10, 20을 입력한다.

strNum1	"10"	num1	10
strNum2	"20"	num2	20
		num3	30

10+20=30

---

6) 다차원 배열 p. 190

배열 항목(값)이 또 다른 배열을 참조할 때 이것을 다차원 배열이라고 한다.
다차원 배열의 선언과 생성 방법은 타입[] [] 변수 = new 타입[길이1][길이2];이다. (행(줄), 열(칸))
변수.length는 1차원 배열의 길이1이 되고,
변수[인덱스].length는 해당 항목이 참조하는 2차원 배열의 길이2를 말한다. 

int[] score = new int[5] //1차원 배열
int score[] = new int[5] //1차원 배열
score[0]=10;
score[1]=20;
score[2]=30;
score[3]=40;
score[4]=50;
int score[] = {10,20,30,40,50}

int[][] score = new int[5][3] //2차원 배열 (5행, 3열)
int score[][] = new int[3][3] //2차원 배열
int[] score[] = new int[5][3] //2차원 배열

score2[0][0]=10; score2[0][1]=20; score2[0][2]=30; 
score2[1][0]=40; score2[1][1]=50; score2[1][2]=60; 
score2[2][0]=70; score2[2][1]=80; score2[2][2]=90; 
score2[3][0]=100; score2[3][1]=110; score2[3][2]=120; 
score2[4][0]=130; score2[4][1]=140; score2[4][2]=150; 

int score2[][] = {
				 {10,20,30},
                 {40,50,60},
                 {70,80,90},
                 {100,110,120},
                 {130,140,150}
                 }

1차원 배열

			0x100
score1	0x100	<---	score1	0	0	0	0	0
				score1[0]	score2[1]	score3[2]	score4[3]	score5[4]

 

		0x100
score1	0x100<---	score1	10	20	30	40	50
			score1[0]	score2[1]	score3[2]	score4[3]	score5[4]

 

		0x100		0x200
score2	0x100<---	score2[0]	0x200<---	0	0	0
				score2[0][0]	score2[0][1]	score2[0][2]
		score2[1]	0x300<---	0x300
				0	0	0
				score2[1][0]	score2[1][1]	score2[1][2]
		score2[2]	0x400<---	0x400
				0	0	0
				score2[2][0]	score2[2][1]	score2[2][2]
		score2[3]	0x500<---	0x500
				0	0	0
				score2[3][0]	score2[3][1]	score2[3][2]
		score2[4]	0x600<---	0x600
				0	0	0
				score2[4][0]	score2[4][1]	score2[4][2]

예제) 배열 속의 배열 

public class P192ArrayInArrayExample {
	public static void main(String[] args) {		
		int[][] mathScores = new int[2][3];
		for (int i=0; i<mathScores.length; i++) {
			for (int k=0; k<mathScores[i].length; k++) {
				System.out.println("mathScores["+i+"]["+k+"]="+mathScores[i][k]);
			}
		}
	System.out.println();

	int[][] englishScores = new int[2][]; //열은 넣기 나름이다.
	//첫번째 줄(index 0)에는 2칸
	englishScores[0] = new int[2];
	//두번째 줄(index 1)에는 3칸
	englishScores[1] = new int[3];
	for (int i=0; i<englishScores.length; i++) {
		for (int k=0; k<englishScores[i].length; k++) {
			System.out.println("englishScores["+i+"]["+k+"]="+englishScores[i][k]);
		}
	}
	System.out.println();
	
	 //두 방식으로 가능하다.//
		/*int[][] javaScores = {
								{95,80},
								{92,96,80}
							};
		javaScores[0][0]=95;
		javaScores[0][1]=80;
		javaScores[1][0]=92;
		javaScores[1][1]=96;
		javaScores[1][2]=80;*/
	
	int[][] javaScores = {{95,80},{92,96,80}};
	for(int i = 0; i<javaScores.length; i++) {
		for(int k = 0; k<javaScores[i].length; k++) {
			System.out.println("javaScores["+i+"]["+k+"]="+javaScores[i][k]);
		}
	}
	}
}

결과)

mathScores[0][0]=0
mathScores[0][1]=0
mathScores[0][2]=0
mathScores[1][0]=0
mathScores[1][1]=0
mathScores[1][2]=0

englishScores[0][0]=0
englishScores[0][1]=0
englishScores[1][0]=0
englishScores[1][1]=0
englishScores[1][2]=0

javaScores[0][0]=95
javaScores[0][1]=80
javaScores[1][0]=92
javaScores[1][1]=96
javaScores[1][2]=80

---

7) 객체를 참조하는 배열 p. 193

예제) 객체를 참조하는 배열 

		0x100
strArray	0x100<---	strArray	Java	Java	0x200<---	0x200
			strArray[0]	strArray[1]	strArray[2]	String	Java

public class P195ArrayReferenceObjectExample {
	public static void main(String[] args) {
		String[] strArray = new String[3];
		strArray[0] = "Java";
		strArray[1] = "Java";
		strArray[2] = new String("Java");//new: 새로운 주소를 만든다.
		
		System.out.println(strArray[0] == strArray[1]);//Java == Java: true
		System.out.println(strArray[0] == strArray[2]);//Java == 0x200: false
		System.out.println(strArray[0].equals(strArray[2]));//Java == Java: true
	}
}

결과) 

true
false
true

---

8) 배열 복사 p. 195

배열 간의 항목 값들을 복사하려면 for문을 사용하거나 System.arraycopy() 메서드를 사용한다.

예제) for문으로 배열 복사

		0x100
oldIntArray	0x100<---	oldIntArray	1	2	3
			oldIntArray[0]	oldIntArray[1]	oldIntArray[2]
		0x200
newIntArray	0x200<---	newIntArray	0	0	0	0	0
			newIntArray[0]	newIntArray[0]	newIntArray[0]	newIntArray[0]	newIntArray[0]

public class P195ArrayCopyByForExample {
	public static void main(String[] args) {
		int[] oldIntArray = {1,2,3}; //1행의 3열의 1차원배열
		
		int[] newIntArray = new int[5];
		
		/* 원리
		 * newIntArray[0]=oldIntArray[0];
		 * newIntArray[1]=oldIntArray[1];
		 * newIntArray[2]=oldIntArray[2];
		 */
		
		//복사한다.
		for(int i=0; i<oldIntArray.length; i++) {
			newIntArray[i] = oldIntArray[i];
		}
		
		//복사된 내용을 출력한다.
		for(int i=0; i<newIntArray.length; i++) {
			System.out.print(newIntArray[i] + ", ");
		}
	}
}

결과) 복사되지 않은 항목은 int[] 배열의 기본 초기값 0이 그대로 유지된다. 

1, 2, 3, 0, 0,

 

System.arraycopy()를 호출하는 방법이다.

//			원본 배열, 원본 배열 시작 인덱스, 복사본 배열, 복사본 배열 시작 인덱스, 길이
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

src 매개값: 원본 배열
srcPos: 원본 배열에서 복사할 항목의 시작 인덱스
dest 매개값: 새 배열
desPos: 새 배열에서 붙여넣을 시작 인덱스
length: 복사할 개수 

원본 배열이 arr1이고 새 배열이 arr2일 경우 arr1의 모든 항목을 arr2에 복사하려면 아래와 같다. 

System.arraycopy(arr1, 0, arr2, 0, arr1.length);

예제) System.arraycopy()로 배열 복사

		0x100
oldIntArray	0x100<---	oldIntArray	java	array	copy
			oldIntArray[0]	oldIntArray[1]	oldIntArray[2]
		0x200
newIntArray	0x200<---	newIntArray	null	null	null	null	null
			newIntArray[0]	newIntArray[0]	newIntArray[0]	newIntArray[0]	newIntArray[0]

public class P196ArrayCopyExample {
	public static void main(String[] args) {
		String[] oldStrArray = {"java", "array", "copy"};
		String[] newStrArray = new String[5];
		//arrayCopy 메소드를 활용해서 복사한다.
		//			원본 배열, 원본 배열 시작 인덱스, 복사본 배열, 복사본 배열 시작 인덱스, 길이
		System.arraycopy(oldStrArray, 0, newStrArray, 0, oldStrArray.length);
		//출력한다.
		for(int i=0; i<newStrArray.length; i++) {
			System.out.println(newStrArray[i] + ", ");
		}
	}
}

결과)

java, 
array, 
copy, 
null, 
null,

---

9) 향상된 for문 p. 197

자바는 배열이나 컬렉션을 좀 더 쉽게 처리하기 위해 향상된 for문을 제공한다. 
향상된 for문은 반복 실행을 하기 위해 루프 카운터 변수와 증감식을 사용하지 않는다.
for문의 괄호 ()에는 배열에서 꺼낸 항목을 저장할 변수 선언과 콜론(:) 그리고 배열을 나란히 작성한다.
배열 및 컬렉션 항목의 개수만큼 반복하고, 자동적으로 for문을 빠져나간다. 

아래의 형태를 말한다.

for (타입 변수 : 배열){
         실행문;
}

for (int score : scores){
          sum += score;
}

반복할 때마다 변수에는 배열에서 가져온 항목이 저장된다. 

자바
for([2]타입 변수 : [1]배열){ //배열의 길이 반복한다. 
	[3]실행문
}

자바스크립트
for 변수 in 배열{

}

1. for문이 처음 실행될 때 [1]배열에서 가져올 첫 번째 값이 존재하는지 평가한다.
2. 가져올 값이 존재하면 해당 값을 [2]변수에 저장한다.
3. [3]실행문을 실행한다.
4. 블록 내부의 [3]실행문이 모두 실행되면 다시 루프를 돌아 [1]배열에서 가져올 다음 값이 존재하는지 평가한다.
5. 만약 다음 항목이 존재하면 [2]변수 → [3]실행문 → [1]배열 순서로 루프를 다시 진행하고, 가져올 다음 항목이 없으면 for문이 종료된다.

따라서 for문의 반복 횟수는 배열의 항목수가 된다. 

참고해보기: https://engpro.tistory.com/196

예제) 향상된 for문 

		0x100
scores	0x100<---	scores	95	71	84	93	87	sum	430
			scores[0]	scores[0]	scores[0]	scores[0]	scores[0]
	첫번째 for		score	95
	두번째 for		score	71
	세번째 for		score	84
	네번째 for		score	93
	다섯번째 for		score	87

for (int score : scores){
          sum += score;
}
for (타입 변수 : 배열){
         실행문;
}

public class P198AdvancedForExample {
	public static void main(String[] args) {
		int[] scores = {95, 71, 84, 93, 87};
		
		int sum = 0;
		//for(int i=0; i<scores.length; i++){ //일반적인 for
		for (int score : scores) { //향상된 for문
			sum += score; //sum = sum + scores[i];
		}
		System.out.println("점수 총합 = " + sum);
		
		double avg = (double) sum / scores.length;
		System.out.println("점수 평균 = " + avg);
	}
}

결과)

점수 총합 = 430
점수 평균 = 86.0

---

마무리

7가지 키워드로 끝내는 핵심 포인트 p. 199

1) 배열: 같은 타입의 데이터를 연속된 공간에 나열하고, 각 데이터에 인덱스(index)를 부여해 놓은 자료구조이다. 

2) 인덱스: 배열 항목에 붙인 번호를 말한다. 0번부터 시작하며 0~(배열길이 -1)까지 범위를 가진다. 

3) 배열 선언: 변수 선언과 비슷한데, 대괄호가 추가되어 타입[] 변수; 형태로 선언된다. 
int[] scores은 int 배열을 선언한다. (scores: 배열 변수) 

4) 배열 생성: 배열을 생성하는 방법은 두 가지이다. 
1. {값1, 값2, 값3, ... }처럼 값 목록으로 생성한다.
2. new 타입[길이];로 생성한다.  

5) 배열 길이: 배열에 저장될 수 있는 항목(값)의 수를 말한다. 배열의 length 필드에 저장되어 있기 때문에 변수.length로 배열 길이를 읽을 수 있다. 

6) 다차원 배열: 배열 항목(값)이 또 다른 배열을 참조할 때 이것을 다차원 배열이라고 한다.
다차원 배열의 선언과 생성 방법은 타입[] [] 변수 = new 타입[길이1][길이2];이다. 
변수.length는 1차원 배열의 길이1이 되고,
변수[인덱스].length는 해당 항목이 참조하는 2차원 배열의 길이2를 말한다. 

7) 향상된 for문: for(타입 변수 : 배열){...}을 말한다.
향상된 for문은 반복 실행을 하기 위해 루프 카운터 변수와 증감식을 사용하지 않는다.
배열의 항목 개수만큼 반복하고, 자동적으로 for문을 빠져나간다.
반복할 때마다 변수에는 배열에서 가져온 항목이 저장된다. 

---

확인 문제 p. 200

Q4) for문을 이용해서 주어진 배열의 항목에서 최대값을 구한다.
예제) for 문 안에 int i = 0; 으로 둔다.
최대값 구하는 거니까 max < array[i]가 조건식이다.

max	0
array	0x100	<---	array	1	5	3	8	2
				array[0]	array[1]	array[2]	array[3]	array[4]

public class P200Q4 {
	public static void main(String[] args) {
		int max = 0; //최대값을 저장하기 위한 변수 (작은 값을 둔다.)
		int[] array = {1,5,3,8,2};
		
		//작성 위치
		for (int i = 0; i < array.length; i++) {
			//max변수에 저장되어 있는 값보다 배열에 저장되어 있는 값이 크면
			if (max < array[i]) {
				//배열에 있는 값을 max변수에 저장한다. 
				max = array[i];
	}
		}
		System.out.print("max: "+max);
	}
}

결과)

max: 8

---

Q5) 중첩 for문을 이용해서 주어진 배열의 전체 항목의 합, 평균값 구하기
예제)
int count = 0; count++; 쓰기
array[i].length로 표기한다.

			0x100
array	0x100<---	array[0]	0x200<---	0x200	95	86
					array[0][0]	array[0][1]
			0x300<---	0x300	83	92	96
					array[1][0]	array[1][1]	array[1][2]
			0x400<---	0x400	78	83	93	87	88
					array[2][0]	array[2][1]	array[2][2]	array[2][3]	array[2][4]

public class P201Q5 {
	public static void main(String[] args) {
		int[][] array = {
				{95, 86},
				{83, 92, 96},
				{78, 83, 93, 87, 88}
		};
		int sum = 0;
		double avg = 0.0;
		
		//작성 위치 
		//sum = 합
		int count = 0;
		for (int i = 0; i<array.length; i++) {
			for (int j = 0; j<array[i].length; j++) {
			sum += array[i][j];
			count++;
		}
		}
		avg = sum / count;
		
		System.out.println("sum: " + sum);
		System.out.println("average: " + avg);
	}
}

결과)

sum: 881
average: 88.0

---

Q6) 입력 받은 최고 점수 및 평균 점수를 구한다.

int[] scores = new int[3];
int[] scores = null;
scores = new int[3];

run	true
studentNum	3
scores	0x100

예제)

public class P201Q6 {
	public static void main(String[] args) {
		boolean run = true; //계속 실행 할 것인지? 안 할 것인지?
		int studentNum = 0; //학생 수(키보드로 입력을 할 수 있게 처리)
		int[] scores = null; //각 학생의 점수(키보드로 입력을 할 수 있게 처리)
		Scanner scanner = new Scanner(System.in);
		
		while(run) {
			System.out.println("====================================");
			System.out.println("1. 학생수 | 2. 점수입력 | 3. 점수리스트 | 4. 분석 | 5. 종료");
			System.out.print("선택>");
			
			int selectNo = Integer.parseInt(scanner.nextLine());
			
			//학생수
			if(selectNo == 1) {
				//작성 위치 
				System.out.println("학생수> ");
				studentNum = Integer.parseInt(scanner.nextLine());
				scores = new int[studentNum];
			//점수 입력	
			} else if(selectNo == 2) {
				//작성 위치 
				for (int i = 0; i < scores.length; i++) {
					System.out.println("scores["+i+"]>");
					scores[i] = Integer.parseInt(scanner.nextLine());
			//점수리스트	
			}} else if(selectNo == 3) {
				//작성 위치 
				for (int i = 0; i < scores.length; i++) {
				System.out.println("scores["+i+"]:"+scores[i]);		
			//분석	
			}} else if(selectNo == 4) {
				//작성 위치 
				//최고 점수를 저장하기 위한 변수
				int max = 0; 
				//합계 점수를 저장하기 위한 변수
				int sum = 0;
				//평균 점수를 저장하기 위한 변수
				double avg = 0.0;
				
				for (int i = 0; i < scores.length; i++) {
					//최고 점수
					if (max < scores[i]) {
						max = scores[i];
						//합계 점수 
						sum += scores[i];
			}
				}	
				//평균 점수
				avg = (double) sum / studentNum;
				
				System.out.println("max: " + max);
				System.out.println("average: " + avg);
			//종료	
			} else if(selectNo == 5) {
				run = false;
			}
		}
		System.out.println("프로그램 종료");
	}
}

결과)

====================================
1. 학생수 | 2. 점수입력 | 3. 점수리스트 | 4. 분석 | 5. 종료
선택>1
학생수> 
2
====================================
1. 학생수 | 2. 점수입력 | 3. 점수리스트 | 4. 분석 | 5. 종료
선택>2
scores[0]>
100
scores[1]>
101
====================================
1. 학생수 | 2. 점수입력 | 3. 점수리스트 | 4. 분석 | 5. 종료
선택>3
scores[0]:100
scores[1]:101
====================================
1. 학생수 | 2. 점수입력 | 3. 점수리스트 | 4. 분석 | 5. 종료
선택>4
max: 101
average: 100.5
====================================
1. 학생수 | 2. 점수입력 | 3. 점수리스트 | 4. 분석 | 5. 종료
선택>5
프로그램 종료

---