티스토리 뷰
📍 배열 (Array)
– 같은 타입 데이터 여러 개를 하나의 묶음(변수)으로 다루는 메모리 공간.
▶ 특징
– 같은 타입 데이터만 저장 가능함.
– 여러 변수에 해당하는 메모리 공간이 연속된 공간에 차례대로 생성됨.
– 한 번 생성된 배열은 크기 변경 불가능!
– 기본 데이터타입과 참조 데이터타입 모두 배열로 사용 가능.
– 배열은 선언, 생성, 초기화의 3단계 과정을 거쳐서 사용함.
– 배열 생성 시, 각 공간에 해당하는 인덱스(번호)가 자동으로 부여됨.
→ 0부터 시작하여 (배열크기 -1)까지 부여됨.
– 배열의 이름(변수명)을 사용하여 배열에 접근 가능. (인덱스 필요)
– 배열의 크기는 배열명.length 속성을 통해 알아낼 수 있음.
– 배열이 생성될 경우, 배열의 데이터 저장 공간은 배열의 데이터타입에 해당하는 기본값으로 자동으로 초기화.
데이터타입 | byte short int |
long | float | double | char | boolean | String |
기본값 | 0 | 0L | 0.0f | 0.0 | 0 또는 \u0000 |
false | null |
▶ 선언 & 생성 & 초기화 / 접근
▸ 배열 선언
데이터타입[ ] 변수명;
– 변수 선언과 유사하나, 데이터타입 뒤에 [ ] 기호를 붙여 배열임을 표시함.
– 배열 공간이 생성되기 전이므로 데이터 저장은 아직 불가능.
– 선언된 배열의 변수는 참조형 변수로 취급됨.
→ 주의! int는 기본형이지만, int[ ]은 참조형이므로 주소값을 가짐. (그래서 변수에 저장, 이를 참조변수라고 함.)
ex ) int a / 1이나 100이나 1000을 아무렇게나 넣을 수 있음.
int[ ] a / Java가 a는 배열이라고 인지해서 주소값을 넣어야한다고 판단함.
▸ 배열 생성
변수명 = new 데이터타입[배열 크기];
– new 키워드를 사용하여 배열 공간을 생성하는데, 데이터타입 뒤의 대괄호 안에 생성할 배열의 크기를 명시함.
– 생성되는 배열의 위치(주소값)를 선언된 배열 타입의 변수에 저장함. (= 참조변수)
– 이제 실제 메모리 공간에 생성되었으므로 데이터 저장이 가능함.
– 생성된 배열에는 자동으로 인덱스 번호가 부여됨.
(인덱스 번호는 '0 ~ 배열크기-1' 까지)
▸ 배열 선언 & 생성
데이터타입[ ] 변수명 = new 데이터타입[배열크기];
▸ 배열 초기화
변수명[인덱스] = 데이터;
– 초기화를 통해 데이터 저장 가능.
▸ 배열 선언 / 생성 & 초기화
데이터타입[ ] 변수명;
변수명 = new 데이터타입[ ] {리터럴 데이터};
– int타입 배열 arr를 먼저 선언함.
– new키워드를 사용하는 방법과 결합하여 문법을 지정해야 하며, 중괄호 안에는 직접적으로 리터럴 데이터를 넣어줌.
– 주의! 배열 크기는 지정하지 않도록 함.
▸ 배열 선언 & 생성 & 초기화
데이터타입[ ] 변수명 = {데이터1, 데이터2, ..., 데이터n};
– 배열 생성 문법을 별도로 명시하지 않고 중괄호를 사용하여 초기화 할 데이터를 리터럴 형태로 전달하면,
해당 데이터 개수만큼 배열 공간이 자동으로 생성됨.
▸ 배열 접근
변수명[인덱스]
– 변수명에 해당하는 주소(배열 공간)에 접근한 뒤, 인덱스에 해당하는 데이터 저장 공간에 접근함.
▸ 반복문을 사용한 배열의 모든 인덱스 접근
for(int i = 0; i<배열명.length; i++) {
배열명[ i ]
}
▸ 배열 선언 시 [ ] 기호 위치에 따른 차이점
int[ ] arr1, arr2;
– arr1, arr2 모두 int[] 타입 변수로 선언됨.
int arr3, arr4[ ];
– arr3은 int, arr4는 int[] 타입 변수로 선언됨.
– 즉, 배열을 여러개 만들 때 위와 같은 문제가 발생할 수 있으므로,
자바에서 추천하는 문법은 데이터타입 뒤에 [] 명시하는걸 권장함.
EX1 ) 배열 미사용 & 사용
• 학생 점수 5개를 저장하고 관리하기
1 ) 배열 사용 X
int score1 = 90, score2 = 60, score3 = 80, score4 = 100, score5 = 50;
int scoreTotal = score1 + score2 + score3 + score4 + score5;
– 배열을 사용하지 않으면 변수 개수도 많아지고 코드가 길어짐.
2 ) 배열 사용 O
// 배열 선언
int[] score;
– int형 정수 여러개를 저장할 배열 score를 선언.
– 아직 데이터를 저장할 수 있는 메모리 공간은 생성되기 전.
// score = 90;
– int[]와 int이므로 type mismatch 에러 발생으로 int형 정수를 넣지 못함.
// 배열 생성
score = new int[5];
– 연속적인 int형 배열 공간 5개를 생성하고, 해당 공간의 메모리 주소를 int[] 타입 변수 score에 저장
– 이 때, 5개의 메모리 공간에는 각각의 인덱스 번호가 자동으로 부여됨.
(인덱스 번호는 0 ~ 4 까지 부여됨.)
// 선언 & 생성
int[] score = new int[5];
– 배열에 접근하여 각 배열 공간의 데이터 출력하기.
– 배열명이 score이므로 score[인덱스] 형식으로 접근 가능.
System.out.println(score);
– 배열명 그대로 출력시 주소값([I@39ed3c8d)이 출력됨.
System.out.println(score[0]); // score 배열의 0번 인덱스 데이터 값 출력
System.out.println(score[1]); // score 배열의 1번 인덱스 데이터 값 출력
System.out.println(score[2]); // score 배열의 2번 인덱스 데이터 값 출력
System.out.println(score[3]); // score 배열의 3번 인덱스 데이터 값 출력
System.out.println(score[4]); // score 배열의 4번 인덱스 데이터 값 출력
– 데이터를 따로 넣지 않았으므로 int타입 기본값으로 0이라는 초기값이 들어가있음.
– 주의! 생성된 배열의 인덱스 범위를 벗어나는 배열 접근 시 오류 발생!
→ 단, 문법적으로 오류가 아니기 때문에 코드 상에서는 알 수 없고, 프로그램 실행 시점에서 오류가 발견됨.
// 배열에 데이터 저장 (초기화)
score[0] = 90;
score[1] = 100;
score[2] = 80;
score[3] = 70;
score[4] = 50;
// 데이터 출력
System.out.println(score[0]);
System.out.println(score[1]);
System.out.println(score[2]);
System.out.println(score[3]);
System.out.println(score[4]);
System.out.println("--------------------------");
// 반복문 사용하여 데이터 출력
// 배열 전체 접근 기본 공식을 사용하여 배열 데이터 출력
for(int i=0; i<score.length; i++) {
System.out.println(i + "번 인덱스 : " + score[i]);
}
– for문을 사용하여 배열 인덱스 범위(0~4)까지 반복하면서,
출력문을 통해 배열 인덱스에 차례대로 접근하여 데이터를 출력함.
– 배열의 모든 인덱스에 접근 시, 조건식에 배열 크기 직접 지정할 경우, 크기가 변경되면 조건식 코드도 변경되어야 함.
– 배열명.length 속성을 사용하여 배열의 크기(길이)를 알아낼 수 있고, 배열의 크기가 변경되어도 동적으로 대응 가능.
✓ 실행 결과
90
100
80
70
50
--------------------------
0번 인덱스 : 90
1번 인덱스 : 100
2번 인덱스 : 80
3번 인덱스 : 70
4번 인덱스 : 50
EX2 ) 배열 선언 & 생성
• int타입 배열
int[] arr = new int[5];
arr[0] = 7;
arr[1] = 14;
arr[2] = 21;
arr[3] = 28;
// arr[4] = 35;
– 초기화 하지 않을 경우, 4번 인덱스는 0번으로 자동 초기화값이 들어감.
– int형 배열의 기본값은 '0'임을 알 수 있음.
for(int i=0; i<arr.length; i++) {
System.out.println("arr[" + i + "] = " + arr[i]);
}
– for문을 사용하여 배열의 모든 인덱스에 접근하여 데이터 출력함.
✓ 실행 결과
arr[0] = 7
arr[1] = 14
arr[2] = 21
arr[3] = 28
arr[4] = 0
• boolean타입 배열
boolean[] arr2 = new boolean[3];
arr2[0] = true;
for(int i=0; i<arr2.length; i++) {
System.out.println("arr2[" + i + "] = " + arr2[i]);
}
– 초기화하지 않은 인덱스 1번, 2번은 기본값이 false로 자동 초기화 됨.
✓ 실행 결과
arr2[0] = true
arr2[1] = false
arr2[2] = false
• String타입 배열
String[] arr3 = new String[3];
arr3[0] = "홍길동";
arr3[1] = "이순신";
for(int i=0; i<arr3.length; i++) {
System.out.println("arr3[" + i + "] = " + arr3[i]);
}
– 초기화하지 않은 인덱스 2번은 기본값이 null로 자동 초기화 됨.
✓ 실행 결과
arr3[0] = 홍길동
arr3[1] = 이순신
arr3[2] = null
• double타입 배열
double[] arr4 = new double[5];
arr4[0] = 1.1;
arr4[1] = 2.2;
arr4[2] = 3.3;
arr4[3] = 4.4;
for(int i=0; i<arr4.length; i++) {
System.out.println("arr4[" + i + "] = " + arr4[i]);
}
– 초기화하지 않은 인덱스 4번은 기본값이 0.0으로 자동 초기화 됨.
✓ 실행 결과
arr4[0] = 1.1
arr4[1] = 2.2
arr4[2] = 3.3
arr4[3] = 4.4
arr4[4] = 0.0
EX3 ) 배열 선언 & 생성 & 초기화
String[] strArr = {"JAVA", "JSP", "CLOUD"};
for(int i=0; i<strArr.length; i++) {
System.out.println(strArr[i]);
}
– String타입 배열 strArr을 생성하고 리터럴로 즉시 초기화까지 한번에 수행하고,
for문을 사용, 배열의 모든 인덱스에 접근하여 데이터를 출력함.
✓ 실행 결과
JAVA
JSP
CLOUD
EX3–1 ) 배열의 최대값 & 최소값 & 합계 & 평균 구하기
• numbers = {3, 2, 14, 21, 100, 4, 2, 1}
– for문이 반복되므로 사용할 변수들을 미리 선언하고,
for문안에 if문을 사용하여 최대 값, 최소 값, 합계, 평균을 한 번에 구할 수 있음.
→ 기준을 미리 정하고 반복하면서 알맞은 값 찾기.
int[] numbers = {3, 2, 14, 21, 100, 4, 2, 1};
int max = numbers[0];
int min = numbers[0];
int sum = 0;
double avg = 0;
– 최대값 & 최소값의 경우, 첫번째 값을 기준으로 두고 배열을 한바퀴 돌면서 알맞은 값을 찾음.
– 모든 수를 더하고 더한 개수만큼 나누기를 하여 구하는 평균은 값이 정수형으로 떨어지지 않으므로 double 타입.
for(int i=0; i<numbers.length; i++) {
// 최대값
if(max < numbers[i]) {
max = numbers[i];
}
// 최소값
if(min > numbers[i]) {
min = numbers[i];
}
// 합계
sum += numbers[i];
// 평균
avg = (double)sum/numbers.length;
}
System.out.println("최대값 : " + max);
System.out.println("최소값 : " + min);
System.out.println("합계 : " + sum);
System.out.println("평균 : " + avg);
– 평균 변수인 avg는 double타입이고, sum / numbers.length = int / int = int이므로, 강제형변환 해줌.
✓ 실행 결과
최대값 : 100
최소값 : 1
합계 : 147
평균 : 18.37※※
※ 번외
int[] a = {1, 2, 3};
int[] b = {4, 5, 6};
int[] c = {7, 8, 9};
a = b;
– b의 주소값을 a에 저장함.
– 기존에 a가 가리키던(참조하던) 1, 2, 3 저장 공간을 버리고,
b가 가리키는 4, 5, 6 저장 공간의 주소값을 전달 받아 참조하게 됨.
– 이 때 기존에 a가 가리키던 1, 2, 3 저장 공간은 더 이상 참조되지 않으므로 불필요한 메모리 공간이 되어,
Garbage Collector (GC)에 의해 정리 대상이 됨.
→ 즉, 더 이상 필요없는 메모리 공간은 자동으로 정리됨.
b = c;
– c의 주소값을 b에 저장함.
– 기존에 b가 참조하던 4, 5, 6 저장 공간을 버리고, c가 가리키는 7, 8, 9 저장 공간의 주소값을 전달받아 참조하게 됨.
– 이 때, 기존 4, 5, 6 저장 공간은 여전히 a에 의해서 참조되고 있으므로 Garbage Collector에 의한 정리 대상이 아님.
📍 배열 내의 데이터에 대한 연산 누적
0. 연산을 누적할 변수 선언 및 초기화.
int total = 0;
1. 배열 생성 및 데이터 저장.
int[ ] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
2. for문을 사용하여 배열 내의 모든 인덱스에 차례대로 접근.
→ 배열의 인덱스 번호를 제어변수로 지정하여, 해당 배열 내의 데이터를 누적 변수에 누적함.
for(int i=0; i<arr.length; i++) {
System.out.println(arr[ i ]);
total += arr[i];
}
3. for문 종료 후 누적 변수 값 사용.
System.out.println(total);
EX1 ) 배열 내의 홀수 & 짝수의 합 구하기
// 배열 생성 & 선언 & 초기화
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int oddTotal = 0;
int evenTotal = 0;
for(int i=0; i<arr.length; i++) {
if(arr[i]%2 == 0) {
evenTotal += arr[i];
}else {
oddTotal += arr[i];
}
}
System.out.println("배열 내의 홀수의 합 : " + oddTotal);
System.out.println("배열 내의 짝수의 합 : " + evenTotal);
– 배열 내의 모든 인덱스에 차례대로 접근하고 각 인덱스 데이터가 홀수, 짝수일 때 각각의 변수에 누적함.
✓ 실행 결과
배열 내의 홀수의 합 : 25
배열 내의 짝수의 합 : 30
EX2 ) 양수 & 음수 배열의 최대값 구하기
• 양수 배열의 최대값
int max = 0;
int[] array = {1, 5, 3, 8, 7};
for(int i=0; i<array.length; i++) {
if(array[i] > max) {
System.out.println(array[i] + "가(이)" + max + "보다 크다");
max = array[i];
System.out.println("max = " + max);
}else {
System.out.println(array[i] + "가(이)" + max + "보다 크지 않다");
}
}
– max에 저장된 값과 배열(array)의 i번에 저장된 값을 비교하여,
max값 보다 배열 데이터(array[ i ])가 더 클 경우, 배열 데이터(array[ i ])를 max에 저장함.
System.out.println("최대값은 : " + max);
– 주의! 최대값 등의 비교 시, 비교 대상을 변수에 직접 저장할 경우 조건에 만족하지 않은 데이터가 있을 수 있음.
→ 따라서 배열 내의 데이터를 비교해야 하는 경우, 비교 대상 값으로 배열 내의 데이터를 갖고 시작하는게 좋음.
ex ) 음수끼리의 최대값을 계산하는데 초기값으로 0을 설정하는 경우,
모든 데이터가 0보다 크지 않으므로 최대값 계산이 불가능하게 됨.
→ 따라서 0 대신 배열의 첫 번째 데이터를 초기값으로 갖고 비교.
✓ 실행 결과
1가(이)0보다 크다
max = 1
5가(이)1보다 크다
max = 5
3가(이)5보다 크지 않다
8가(이)5보다 크다
max = 8
7가(이)8보다 크지 않다
최대값은 : 8
• 음수 배열의 최대값
int[] array2 = {-9, -5, -3, -8, -7};
int max2 = array2[0];
– array2 배열의 0번 인덱스 데이터를 최대값으로 저장함.
→ 0번 인덱스 데이터값이 기준이 됨.
– 주의! 0번의 데이터를 이미 최대값으로 저장했기 때문에 0번 인덱스를 제외한 나머지값만 비교하면 됨. (1번부터 반복)
for(int i=0; i<array2.length; i++) {
System.out.println(array2[i] + " vs " + max2);
if(array2[i] > max2){
max2 = array2[i];
}
}
System.out.println("max2 = " + max2);
✓ 실행 결과
-9 vs -9
-5 vs -9
-3 vs -5
-8 vs -3
-7 vs -3
max2 = -3
Q ) 거스름돈을 몇 개의 동전으로 지불할 수 있는지 계산하는 문제.
변수 money의 금액을 동전으로 바꾸었을 때, 각각 몇 개의 동전이 필요한지 계산해서 출력하기.
단, 가능한 한 적은 수의 동전으로 거슬러 주어야 함.
<출력예시>
money = 2680;
500원 = 5
100원 = 1
50원 = 1
10원 = 3
A )
// 배열 생성(동전의 액수 = 종류)
int[] coinUnit = {500, 100, 50, 10};
// 거스름돈 변수(money)선언 및 초기화
int money = 2680;
System.out.println("money = " + money + "원");
// for문을 통해 배열 접근
for(int i=0; i<coinUnit.length; i++) {
System.out.println(coinUnit[i] + "원 : " + (money/coinUnit[i]) + "개");
money %= coinUnit[i];
System.out.println("남은 거스름돈 = " + money + "원");
}
– 거스름돈(money)을 각 동전으로 나누었을 때 몫 = 필요 동전 수
– 거스름돈(money)을 각 동전으로 나눈 나머지 = 남은 거스름돈
✓ 실행 결과
money = 2680원
500원 : 5개
남은 거스름돈 = 180원
100원 : 1개
남은 거스름돈 = 80원
50원 : 1개
남은 거스름돈 = 30원
10원 : 3개
남은 거스름돈 = 0원
📍 2차원 배열
– 1차원 배열 여러개의 묶음을 관리하는 배열.
– 행과 열로 이루어진 테이블(표) 구조와 유사한 구조의 배열.
→ 행과 열의 인덱스는 1차원 배열과 동일 (0부터 시작)
▸ 2차원 배열 선언 & 생성
데이터타입[ ][ ] 변수명 = new 데이터타입[행크기][열크기];
▸ 2차원 배열 선언 & 생성 & 초기화
데이터타입[ ][ ] 변수명 = {
{값1, 값2, ..., 값n}, // 0행 (0열, 1열, ..., n열)
{값1, 값2, ..., 값n}, // 1행 (0열, 1열, ..., n열)
...
{값1, 값2, ..., 값n}, // n행 (0열, 1열, ..., n열)
};
▸ 2차원 배열 크기
1. 행의 크기
변수명.length
2. 열의 크기
변수명[행번호].length
▸ 2차원 배열 모든 요소 접근
for(int i=0; i<변수명.length; i++) { // 행 반복
for(int j=0; i<변수명[ i ].length; j++) { // 열 반복
변수명[ i ][ j ]
}
}
▸ 행 생성 후 → 열 생성
데이터타입[ ][ ] 배열명 = new 데이터타입[행크기][ ];
– 2차원 배열은 행을 먼저 생성한 후 별도로 열을 각각 생성 가능.
int[ ][ ] arr3 = new int[3][ ];
– 선언! 3행의 공간이 먼저 생성됨.
EX1 ) 2차원 배열 선언 & 생성
• 배열 선언 & 생성 후, 데이터 저장
// int[][] arr;
// arr = new int[3][2];
int[][] arr = new int[3][2];
– 위의 두 문장을 한 문장으로 결합하여 배열 선언 & 생성 동시에 수행함.
– 3행 2열 크기의 배열 (= 표)이 생성됨.
1열 | 2열 | |
1행 | (0,0) | (0,1) |
2행 | (1,0) | (1,1) |
3행 | (2,0) | (2,1) |
– 배열은 인덱스값으로 접근하므로, 3행2열 크기의 배열을 표로 생각할때는 0부터 시작하기.
arr[0][0] = 1; arr[0][1] = 2;
arr[1][0] = 3; arr[1][1] = 4;
arr[2][0] = 5; arr[2][1] = 6;
1열 | 2열 | |
1행 | 1 (0,0) | 2 (0,1) |
2행 | 3 (1,0) | 4 (1,1) |
3행 | 5 (2,0) | 6 (2,1) |
– 배열의 인덱스값에 접근하여 데이터를 저장함.
System.out.println(arr[0][0]); // 1
System.out.println(arr[0][1]); // 2
System.out.println(arr[1][0]); // 3
System.out.println(arr[1][1]); // 4
System.out.println(arr[2][0]); // 5
System.out.println(arr[2][1]); // 6
– 배열의 인덱스값에 접근하여 데이터를 출력해봄.
• 배열 크기 알아내기
// 배열의 행 크기
// 배열명.length
System.out.println("배열 arr의 행 크기 : " + arr.length);
// 배열의 각 행에 대한 열 크기
// 배열명[행 인덱스].length
System.out.println("배열 arr의 0번 행의 열 크기 : " + arr[0].length);
System.out.println("배열 arr의 1번 행의 열 크기 : " + arr[1].length);
System.out.println("배열 arr의 2번 행의 열 크기 : " + arr[2].length);
✓ 실행 결과
배열 arr의 행 크기 : 3
배열 arr의 0번 행의 열 크기 : 2
배열 arr의 1번 행의 열 크기 : 2
배열 arr의 2번 행의 열 크기 : 2
• 반복문을 사용하여 2차원 배열의 모든 요소에 접근
// 바깥쪽 for문
for(int i=0; i<arr.length; i++) {
// 안쪽 for문
for(int j=0; j<arr[i].length; j++) {
// System.out.println(arr[i][j]); // 내가 원하는 형태로 안나옴
System.out.print(arr[i][j] + " "); // 공백 추가하니 깔끔하게 나옴
}
System.out.println();
}
– 바깥쪽 for문을 사용하여 행 크기 만큼 반복함. (1차원 배열 접근과 동일)
– 안쪽 for문을 사용하여 각 행의 열 크기만큼 반복함.
✓ 실행 결과
1 2
3 4
5 6
EX2 ) 2차원 배열 선언 & 생성 & 초기화
int[][] arr2 = {
{1, 2}, // 1행 (1열, 2열)
{3, 4}, // 2행 (1열, 2열)
{5, 6}, // 3행 (1열, 2열)
};
– 전체 블록 내의 중괄호(블록) 개수 = 행의 개수
– 내부 중괄호(블록)내의 데이터 개수 = 열의 개수
→ 3행2열의 배열을 생성함.
– 주의! 해당 배열에 접근할때는 인덱스값으로 접근해야하므로 항상 0부터 / (0,0)부터 시작한다고 생각하기.
1열 | 2열 | |
1행 | 1 (0,0) | 2 (0,1) |
2행 | 3 (1,0) | 4 (1,1) |
3행 | 5 (2,0) | 6 (2,1) |
for(int i=0; i<arr2.length; i++) {
for(int j=0; j<arr2[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
– 중첩 for문을 사용하여 2차원 배열 차례대로 접근함.
✓ 실행 결과
1 2
3 4
5 6
EX3 ) String타입의 배열
String[][] fruits = {
{"사과", "바나나", "키위"},
{"수박", "참외", "메론"},
{"복숭아", "포도", "오렌지"},
};
for(int i=0; i<fruits.length; i++) {
for(int j=0; j<fruits[i].length; j++) {
System.out.print(fruits[i][j] + " ");
}
System.out.println();
}
– 3행3열의 배열을 선언 & 생성 & 초기화까지 한번에 하고, 중첩 for문을 사용하여 2차원 배열에 차례대로 접근함.
✓ 실행 결과
사과 바나나 키위
수박 참외 메론
복숭아 포도 오렌지
EX4 ) 행 생성 후 별도로 열 생성
– 각 행에 접근하여 열을 생성하는 코드를 작성해야 함.
• 방법1 ) 선언 / 생성 / 초기화 → 크기를 못정했을 때
– 선언
int[][] arr3 = new int[3][];
– 생성
arr3[0] = new int[3];
// 정수형 배열 3개를 저장하는 공간을 생성 후 0번행에 주소를 저장
arr3[1] = new int[2];
// 정수형 배열 2개를 저장하는 공간을 생성 후 1번행에 주소를 저장
arr3[2] = new int[4];
// 정수형 배열 4개를 저장하는 공간을 생성 후 1번행에 주소를 저장
– 초기화
arr3[0][0] = 1; arr3[0][1] = 2; arr3[0][2] = 3;
arr3[1][0] = 1; arr3[1][1] = 2;
arr3[2][0] = 1; arr3[2][1] = 2; arr3[2][2] = 3; arr3[2][3] = 4;
• 방법2 ) 선언 / 생성 & 초기화 → 크기를 정했을 때
– 선언
int[][] arr3 = new int[3][];
– 생성 & 초기화
arr3[0] = new int[] {1, 2, 3};
arr3[1] = new int[] {1, 2};
arr3[2] = new int[] {1, 2, 3, 4};
– 각 행의 공간에 열 공간을 생성하면서 데이터 초기화까지 동시에 수행함.
• 방법3 ) 선언 & 생성 & 초기화
int[][] arr3 = {
{1, 2, 3},
{1, 2},
{1, 2, 3, 4},
};
for(int i=0; i<arr3.length; i++) {
for(int j=0; j<arr3[i].length; j++) {
System.out.print(arr3[i][j] + " ");
}
System.out.println();
}
✓ 실행 결과
1 2 3
1 2
1 2 3 4
Q1 ) 2차원 배열을 생성하고, 해당 배열의 평균과 합계를 구하시오.
A1 )
int[][] array = {
{95, 86},
{83, 92, 96},
{78, 83, 93, 87, 88},
};
double avg = 0.0;
int count = 0;
int sum = 0;
– 평균은 딱 떨어지지 않으므로 double타입으로 함.
– 행에 열이 몇 개인지 개수를 저장할 변수 count, 값을 모두 더할 누적변수 sum 생성함.
→ sum / count == avg
for(int i=0; i<array.length; i++) {
for(int j=0; j<array[i].length; j++) {
sum += array[i][j];
count++; // 각 열의 카운트(개수)를 계산
}
}
avg = (double)sum / count;
System.out.println("sum = " + sum);
System.out.println("avg = " + avg);
– array 배열 내의 모든 요소를 누적변수 sum에 누적함.
– 평균은 합계 계산이 완료된 후 계산하면 되기 때문에 for문 종료 후 계산.
✓ 실행 결과
sum = 881
avg = 88.1
Q2 ) 학생 이름을 1차원 배열(names)에 저장하고,
학생 점수를 2차원 배열(score)에 다음과 같이 저장 후 출력하시오.
< 학생별 점수표 > | |||
국어 | 영어 | 수학 | |
박연진 | 80 | 70 | 80 |
이사라 | 90 | 90 | 90 |
전재준 | 50 | 60 | 77 |
문동은 | 100 | 100 | 100 |
최혜정 | 80 | 80 | 60 |
또한, 학생별 총점을 계산하여 1차원 배열(studentTotal)에 다음과 같이 저장 후 출력하시오.
< 학생별 총점 > | |
박연진 : | 230점 |
이사라 : | 270점 |
전재준 : | 187점 |
문동은 : | 300점 |
최혜정 : | 220점 |
A2 )
• 학생 이름
String[] names = {"박연진", "이사라", "전재준", "문동은", "최혜정"};
– 1차원 배열에 저장함.
• 학생별 점수표
int[][] score = {
{80, 70, 80},
{90, 90, 90},
{50, 60, 77},
{100, 100, 100},
{80, 80, 60},
};
System.out.println(" < 학생별 점수표 >");
System.out.println(" 국어 " + "영어 " + "수학 ");
for(int i=0; i<score.length; i++) {
System.out.print(names[i] + " : ");
for(int j=0; j<score[i].length; j++) {
// System.out.print(score[i][j] + " ");
System.out.printf("%3d ", score[i][j]);
// 100이 있으므로 자리수를 깔끔하게 맞춰줌
}
System.out.println();
}
System.out.println("------------------------------");
✓ 실행 결과
< 학생별 점수표 >
국어 영어 수학
박연진 : 80 70 80
이사라 : 90 90 90
전재준 : 50 60 77
문동은 : 100 100 100
최혜정 : 80 80 60
------------------------------
• 학생별 총점
System.out.println(" < 학생별 총점>");
int[] studentTotal = new int[5]; // = names.length
1 ) 반복문 사용 X
studentTotal[0] = score[0][0] + score[0][1] + score[0][2];
studentTotal[1] = score[1][0] + score[1][1] + score[1][2];
studentTotal[2] = score[2][0] + score[2][1] + score[2][2];
studentTotal[3] = score[3][0] + score[3][1] + score[3][2];
studentTotal[4] = score[4][0] + score[4][1] + score[4][2];
for(int i=0; i<studentTotal.length; i++) {
System.out.println(names[i] + " : " +studentTotal[i] + "점");
}
2 ) 반복문 사용 O
for(int i=0; i<score.length; i++) {
for(int j=0; j<score[i].length; j++) {
studentTotal[i] += score[i][j];
}
// 1명의 점수 누적이 끝난 시점에서 이름과 총점을 출력
System.out.println(names[i] + " : " + studentTotal[i] + "점");
}
– 학생 점수 인덱스 중 행번호에 해당하는 인덱스가 학생 총점의 인덱스로 사용될 수 있음!
→ 즉, 각 학생의 행번호(i)를 사용하여 학생의 3과목 점수를, 총점 배열의 인덱스에 행번호를 사용하여 누적함.
✓ 실행 결과
< 학생별 총점>
박연진 : 230점
이사라 : 270점
전재준 : 187점
문동은 : 300점
최혜정 : 220점
'JAVA' 카테고리의 다른 글
오버로딩 (메서드 오버로딩 / 생성자 오버로딩 / 문제점 & 해결책) (0) | 2023.03.12 |
---|---|
생성자 (기본 생성자 / 파라미터 생성자) (0) | 2023.03.06 |
접근 제한자(public & private) / getter & setter 메서드 (0) | 2023.02.28 |
메서드 (method) — 형태에 따른 정의 & 호출 (0) | 2023.02.22 |
보조 제어문 (break / continue) (0) | 2023.02.11 |
- Total
- Today
- Yesterday
- gitbash
- null
- 업캐스팅
- model2
- 숫자형
- Java
- mysql
- 매개변수
- 주석문
- 문자형
- JSTL
- 로컬저장소
- 제어문
- jsp
- 출력문
- github
- 데이터타입
- DB
- Git
- 오버라이딩
- 내장객체
- 단일행함수
- 다형성
- Method
- 원격저장소
- 논리형
- 인자
- Dao
- javascript
- Object
일 | 월 | 화 | 수 | 목 | 금 | 토 |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 |