[자바]/자바의 정석 - 3판
Chapter.05 배열
쿠릉쿠릉 쾅쾅
2021. 8. 29. 00:02
728x90
◎ 배열
- 배열은 같은 타입의 여러 변수를 하나의 묶음으로 다루는 것
- 배열은 참조값으로만 접근할 수 있음
- 많은 양의 값(데이터)을 다룰 때 유용하다
- 배열의 각 요소는 서로 연속적임
- 배열의 인덱스 ㅡ 각 요소(저장공간)에 자동으로 붙는 번호
- 인덱스(index)의 범위는 0부터 '배열길이-1' 까지
- 여기서 배열 이름 score는 배열을 다루는데 필요한 참조변수일 뿐 값을 저장하기 위한 공간이 아님
배열의 선언과 생성
- 배열을 다루기 위한 참조변수의 선언
- 타입 또는 변수 이름 뒤에 대괄호 [] 를 붙여서 배열을 선언함
- '타입[] 변수 이름' 선언 방식으로 쓰는거 선호 ㅡ 대괄호[ ]가 타입의 일부라고 생각하는게 좋음
// 선언 방법
타입[] 변수 이름; // 배열 선언 (배열을 다루기 위한 참조변수 선언)
변수 이름 = new 타입[길이] // 배열 생성 (실제 저장공간을 생성)
// ex.1
int [] score; // int 타입의 배열을 다루기 위한 참조변수 score 선언
score = new int [5] // int 타입의 값 5개를 저장할 수 있는 배열 생성
score[3] = 100; // 배열 4번째 요소에 100을 저장함
int value = score[3]; // 배열 score의 4번째 요소의 값을 value에 저장함
// ex.2
int[] score = new int[5]; // 배열의 선언과 생성을 동시에
배열의 길이
- 배열이름.length
- 배열의 길이는 int형 상수임
- 배열은 한번 생성하면 그 길이를 바꿀 수 없다.
- 배열의 길이는 0 또는 양의 정수이어야하며 최대값은 int 타입의 최대값인 약 20억임
- 배열의 길이가 0인 배열도 생성 가능함
// ex.1
int[] arr = new int[5]; // 길이가 5인 int 배열
int tmp = arr.length; // arr.length의 값은 5이고 tmp 에 5가 저장 됨
// ex.2 배열의 길이가 0인 배열들
int[] arr = new int[0];
int[] arr2 = new int[]{};
int[] arr3 = {};
배열의 초기화
- 배열의 각 요소에 처음으로 값을 저장하는 것
- 배열은 생성과 동시에 자동적으로 자신의 타입에 해당하는 기본값으로 초기화 됨
// 배열 초기화 방법 1
int [] score = new int[5];
score[0] = 50;
score[1] = 60;
score[2] = 70;
score[3] = 80;
score[4] = 90;
// 배열 초기화 방법 2
int[] score = new int[5];
for (int i=0; i < score.length; i++) { // for문을 이용하려면 배열 값의 규칙이 필요함
score[i] = i * 10 + 50;
}
// 배열 초기화 방법 3
int[] score = new int[]{50, 60, 70, 80, 90};
// 배열 초기화 방법 4 ← 주로 이 방법으로 씀
int[] score = {50,60,70,80,90}; // new int[]를 생략할 수 있음
// 배열 초기화 방법 4 주의사항
int [] score;
score = {50, 60, 70, 80 ,90}; // 에러. new int[] 를 생략할 수 없음
socre = new int[]{50,60, 70, 80, 90}; // ok
배열의 출력
- 배열을 출력할 때, char 배열을 제외한 나머지 배열들은 인덱스 없이 'System.out.println(배열명)' 으로 쓰면 안됨.
- for 문을 이용하여 '배열명[인덱스]' 로 배열 출력 가능
- 주로 배열을 출력할 때는 'Arrays.toString(배열명)' 을 씀
- 베열의 모든 요소를 '['첫번째 요소', '두번째 요소', ...]' 와 같은 형식의 문자열로 만들어서 반환함
- import java.util.*; 추가 해야함
// ex.1
int[] iArr = {100, 95, 80, 70, 60};
System.out.println(iArr); // [I@156643d4 와 같은 형식의 문자열이 출력됨
// ex.2
char[] chArr = {'a', 'b', 'c', 'd'};
System.out.println(chArr); // abcd 가 출력됨
// ex.3 for 문을 이용한 배열 출력
int[] iArr2 = {50,60,80,70};
for(int i=0; i < iArr2.length; i++){
System.out.println(iArr2[i]); // 배열의 요소를 순서대로 하나씩 출력함
}
// ex.4 Arry.toString() 이용하여 배열의 모든 요소 출력 ← 주로 이 방법을 씀
import java.util.Arrays; // ctrl + shift o 누르면 자동으로 import 문 추가됨
int[] iArr3 = {10,50,30,40};
System.out.println(Arrays.toString(iArr3)); // [10, 50, 30, 40]
// ex.5
int[] score = new int[5];
int k = 1;
score[0] = 50;
score[1] = 60;
score[k+1] = 70; // score[2] = 70;
score[3]= 80;
score[4] = 90;
int tmp = score[k+2] + score[4]; // int tmp = score[3] + score[4]
for(int i=0; i<5; i++) {
System.out.printf("score[%d] : %d%n", i, score[i]);
}
System.out.printf("tmp:%d%n", tmp); // 170
// ex.6
import java.util.Arrays;
int[] iArr1 = new int[10];
int[] iArr2 = new int[10];
int[] iArr3 = {10,20,30,40,50,60};
char[] chArr = {'a','b','c','d'};
// iArr1에 1~10 순차대로 값 지정하기
for(int i=0; i<iArr1.length;i++) iArr1[i] = i+1;
// iArr2에 1~10 랜덤으로 값 부여하기
for(int i=0; i<iArr2.length;i++) iArr2[i] = (int)(Math.random()*10) +1 ;
// iArr1 배열 출력하기
for(int i=0; i<iArr1.length; i++) System.out.print(iArr1[i] + ","); // 1,2,3,4,5,6,7,8,9,10,
System.out.println();
// iArr2 배열 출력하기 ← 랜덤 숫자라 출력마다 값이 바뀜
System.out.println(Arrays.toString(iArr2)); // [3, 1, 8, 4, 9, 1, 7, 1, 3, 8]
// iArr3 배열 출력하기
System.out.println(Arrays.toString(iArr3)); // [10, 20, 30, 40, 50, 60]
// iArr3 배열 참조값 출력하기 ← 참조값이 출력마다 바뀔 수 있음
System.out.println(iArr3); // [I@36aa7bc2
// chArr 배열 출력하기
System.out.println(chArr); // abcd
배열 예제
// ex.1 배열 요소의 총합과 평균 구하기
int sum = 0; // 총합을 저장하기 위한 변수
float average = 0f; // 평균을 저장하기 위한 변수
int[] score = {100, 88, 100, 100, 90};
for (int i = 0; i<score.length; i++){
sum += score[i];
}
average = sum/(float)score.length; // 계산 결과를 float 타입으로 얻으려 형변환
System.out.println("총합 : " + sum); // 총합 : 478
System.out.println("평균 : " + average); // 평균 : 95.6
// ex.2 배열의 요수 중에서 최대값과 최소값 구하기
int[] score = {79, 88, 91, 33, 100, 55, 95};
int max = score[0]; // 배열의 첫 번째 값으로 최대값 초기화
int min = score[0]; // 배열의 첫 번째 값으로 최소값 초기화
for (int i=1; i < score.length; i++) { // 배열의 두 번째 요소부터 읽기 위해서 i를 1로 초기화
if(score[i] > max){
max = score[i];
} else if (score[i] < min){
min = score[i];
}
} // end of for
System.out.println("최대값 = " + max); // 최대값 : 100
System.out.println("최소값 = "+ min); // 최소값 : 33
// ex.3 배열의 요소의 순서를 반복해서 바꿈 (숫자 섞기)
import java.util.Arrays;
int[] numArr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.println(Arrays.toString(numArr));
for (int i=0; i < numArr.length; i++){
int n = (int)(Math.random()*10); // 0~9 중의 한 값을 임의로 얻음
// numArr[i] 와 numArr[n]의 값을 서로 바꿈
int tmp = numArr[i];
numArr[i] = numArr[n];
numArr[n] = tmp;
} //end of for
System.out.println(Arrays.toString(numArr));
// ex.4 배열의 요소의 순서를 반복해서 바꿈 (로또 번호 뽑기)
import java.util.Arrays;
int[] ball = new int[45]; // 45개의 정수값 저장하기위한 배열 생성
// 배열의 각 요소에 1~45 값 저장
for (int i=0; i < ball.length; i++){
ball[i] = i+1; // ball[0]에 1이 저장됨
}
System.out.println(Arrays.toString(ball));
int tmp = 0; // 두 값을 바꾸는데 사용할 임시 변수
int j = 0; // 임의의 값을 얻어서 저장할 변수
//배열의 i번째 요소와 임의의 요소에 저장된 값을 서로 바궈서 값을 섞음
// 0번째 부터 5번째 요소까지 모두 6개만 바꿈
for(int i=0; i < 6; i++){
j = (int)(Math.random()*45); // 0~44 범위의 임의의 값을 얻음
tmp = ball[i];
ball[i] = ball[j];
ball[j] = tmp;
}
//배열 ball의 앞에서 부터 6개의 요소를 출력한다
for(int i=0; i < 6; i++){
System.out.printf("ball[%d] = %d%n", i, ball[i]);
}
배열의 길이 변경하는 방법
- 더 큰 배열을 새로 생성함 → 기존 배열의 내용을 새로운 배열에 복사함
배열의 복사
- 배열의 복사는 비효율적이기 때문에 처음부터 배열을 생성할 때, 기존 길이의
- for문을 이용해서 배열을 복사할 수 있음
- 기존 배열의 길이보다 2배 정도의 길이로 생성하는것이 좋음
- System.arraycopy() 를 이용한 배열 복사
- 배열복사는 for 문보다 System.arraycopy() 가 더 효율적임
- Arrays.copyOf(배열명, 복사할 요소의 개수)
- import java.util.Arrays 추가 할 것
- Arrays.copyOfRange(배열명, int from, int to) ㅡ int to 인덱스 값은 포함 안됨
- import java.util.Arrays 추가 할 것
System.arraycopy() vs Arrays.copyOf()
- 서로 기능은 같음
- System.arraycopy() 는 native 코드를 호출해서 속도면에서 2배 이상 빠름
- Arrays.copyOf() 가 더 직관적임
- 전체 길이를 전부 복사하거나, 복사 대상의 객체를 유지하지 않아도 된다면 Arrays.copyOf() 를 사용할 것
- 복사하는 길이를 명시하거나, 객체를 유지해야 한다면 System.arraycopy() 를 사용할 것
예제
/* ex.1 for문을 이용한 배열 복사 */
int[] arr = new int[5]; // 기존 배열
int[] tmp = new int[arr.length*2]; // 기존 배열의 길이가 2배인 새로운 배열 생성
for(int i=0; i<arr.length; i++) tmp[i] = arr[i]; // arr[i] 값을 tmp[i] 값에 대입
// 기존 arr 배열의 참조값이 tmp 배열의 참조값으로 바뀜. 기존 arr 배열의 참조값이 사라져서 기존 arr 배열도 사라짐
arr = tmp;
/* ex.2 for 문을 이용한 배열복사2 */
import java.util.Arrays;
int[] arr = new int[5];
// arr 배열에 1~5 까지 순서대로 값 대입
for(int i=0; i<arr.length; i++) arr[i] = i+1;
// 변경전 arr 배열 출력
System.out.println("[변경전]"); // [변경전]
System.out.println(arr.length); // 5
System.out.println(Arrays.toString(arr)); // [1,2,3,4,5]
// 복사할 배열 생성
int[] tmp = new int[arr.length*2];
for(int i=0; i<arr.length; i++) tmp[i] = arr[i];
arr = tmp;
// 변경후 arr 배열 출력
System.out.println("[변경후]"); // [변경후]
System.out.println(arr.length); // 10
System.out.println(Arrays.toString(arr)); // [1,2,3,4,5,0,0,0,0,0]
/* ex.3 System.arraycopy()를 이용하여 배열 복사하기 */
char[] abc = {'A', 'B', 'C', 'D'};
char[] num = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
System.out.println(abc); // ABCD
System.out.println(num); // 0123456789
// 배열 abc와 num을 붙여서 하나의 배열(result)로 만듦
char[] result = new char[abc.length + num.length];
System.arraycopy(abc, 0, result, 0, abc.length);
System.arraycopy(num, 0, result, abc.length, num.length);
System.out.println(result); // ABCD0123456789
// 배열 abc를 배열 num의 첫 번째 위치로부터 배열 abc의 길이만큼 복사
System.arraycopy(abc, 0, num, 0, abc.length);
System.out.println(num); // ABCD456789
// 배열 num의 인덱스 6위치에서 배열 abc의 첫 번째 위치로부터 3개 복사
System.arraycopy(abc, 0, num, 6, 3);
System.out.println(num); // ABCD45ABC9
// ex.4 Arrays.copyOf()
import java.util.Arrays;
int[] arr = {0,1,2,3,4,5,6};
int[] arr2 = Arrays.copyOf(arr, 3); // [0,1,2]
int[] arr3 = Arrays.copyOf(arr, 9); // [0,1,2,3,4,5,6,0,0]
int[] arr4 = Arrays.copyOf(arr, arr.length); // [0,1,2,3,4,5,6]
System.out.println(Arrays.toString(arr2)); // [0,1,2]
System.out.println(Arrays.toString(arr3)); // [0,1,2,3,4,5,6,0,0]
System.out,println(Arrays.toString(arr4)); // [0,1,2,3,4,5,6]
// ex.5 Arrays.copyOfRange()
import java.util.Arrays;
int[] arr = {0,1,2,3,4,5,6};
int[] arr2 = Arrays.copyOfRange(arr, 2, 4); // [2,3]
int[] arr3 = Arrays.copyOfRange(arr, 3, 9); // [3,4,5,6,0,0]
System.out.println(Arrays.toString(arr2)); // [2,3]
System.out.println(Arrays.toString(arr3)); // [3,4,5,6,0,0]
배열의 활용
- 총합과 평균
- 최대값과 최소값
- 섞기(shuffle)
- 임의의 값으로 배열 채우기
- 정렬하기(sort)
- 빈도수 구하기
/* ex.1 총합과 평균 */
int sum = 0; // 총합을 저장하기 위한 변수
float average = 0f; // 평균을 저장하기 위한 변수
int[] score = {100,90,88,100,100};
// 총합
for(int i=0; i<score.length; i++) sum += score[i];
// 평균
average = sum/(float)score.length;
System.out.println(sum); // 478
System.out.println(average); // 95.6
/* ex.2 최대값과 최소값 */
int[] score = {79, 88, 91, 33, 100, 55, 95};
int max = score[0]; // 배열의 첫 번째 값으로 최대값을 초기화
int min = score[0]; // 배열의 첫 번째 값으로 최소값을 초기화
for(int i=0; i<score.length; i++){
if (max < score[i]) max = score[i];
else if (min > score[i]) min = score[i];
}
System.out.println(max); // 100
System.out.println(min); // 33
/* ex.3-1 순서 섞기(shuffle) ㅡ 카드 뽑기 */
import java.util.Arrays;
int[] score = new int[10];
for (int i=0; i<score.length; i++) score[i] = i;
// 순서 섞기 전
System.out.println(Arrays.toString(score)); // [0,1,2,3,4,5,6,7,8,9]
for (int i=0; i<score.length; i++){
// score[i] 값이랑 score[n] 값 서로 바꾸기
int n = (int)(Math.random()*10);
int tmp = score[i];
score[i] = score[n];
score[n] = tmp;
}
// 순서 섞기 후
System.out.println(Arrays.toString(score)); // [1, 0, 3, 4, 5, 9, 6, 7, 2, 8] ← 실행마다 값이 다름
/* ex.3-2 순서 섞기(shuffle) ㅡ 로또 번호 생성 */
import java.util.Arrays;
// 로또 볼 번호 초기화
int[] ball = new int[45];
for(int i=0; i<ball.length; i++) ball[i] = i+1;
// 로또 볼 6개 값만 순서 섞기
for(int i=0; i<6; i++){
int n = (int)(Math.random()*45);
int tmp = ball[i];
ball[i] = ball[n];
ball[n] = tmp;
}
// ball 번호 6번째까지 값을 새로운 배열에 복사
int[] lotto = Arrays.copyOf(ball,6);
System.out.println(Arrays.toString(lotto)); // [6, 1, 35, 9, 17, 40] ← 실행마다 값이 달라짐
/* ex.4 임의의 값으로 배열 채우기 */
import java.util.Arrays;
int[] code = {-4, -1, 3, 6, 11};
int[] arr = new int[10]; // 배열 code에 저장된 값들 중 하나를 임의의 값으로 채울 배열 생성
for(int i=0; i<arr.length; i++){
int n = (int)(Math.random()*code.length);
arr[i] = code[n];
}
System.out.println(Arrays.toString(arr)); // [3, 3, 3, 6, -1, 6, -1, 11, -1, 3] ← 실행마다 값이 달라짐
/* ex.5 정렬하기(sort) ㅡ 오름차순으로 정렬하기 */
// 이 정렬방법은 버블 정렬(bubble sort) 방법임. 비효율적이지만 가장 간단함
int[] numArr = new int[10];
for(int i=0; i<numArr.length;i++) System.out.print(numArr[i] = (int)(Math.random()*10));
System.out.println();
for(int i=0; i<numArr.length-1; i++){
boolean changed = false; // 자리 바꿈이 발생했는지 체크함
for(int j=0; j<numArr.length-1-i; j++){
if(numArr[j] > numArr[j+1]){
int temp = numArr[j];
numArr[j] = numArr[j+1];
numArr[j+1] = temp;
changed = true; // 자리바꿈이 발생했으니 true
} // end of if
} // end for j
if(!changed) break; // 자리 바꿈이 없으면 반복문을 벗어남
for(int k=0; k<numArr.length; k++) System.out.print(numArr[k]);
System.out.println();
} // end for i
/* ex.6 빈도수 구하기 */
int[] numArr = new int[10];
int[] counter = new int[10];
for(int i=0; i<numArr.length; i++) System.out.print(numArr[i] = (int)(Math.random()*10));
System.out.println();
for(int i=0; i<numArr.length; i++) counter[numArr[i]]++;
for(int i=0; i<numArr.length; i++) System.out.printf("%d의 개수: %d%n", i, counter[i]);
◎ String 배열
- 여러가지 문자열을 저장할 수 있는 배열
- string은 기본형이 아닌 참조형임
- 참조형 배열의 경우 배열에 저장되는 것은 객체의 주소임
- 참조형 배열을 객체 배열이라고 부름
배열 선언과 생성
- string[] name = new String[3]; // 3개의 문자열을 담을 수 있는 배열 생성
- string 기본값이 null 이기 때문에 string 배열의 기본값도 null 로 초기화됨
// 배열의 선언과 생성을 동시에 함 ← 이 방법이 제일 많이 쓰임
String[] name = {"Kim", "Park", "Yi"};
예제
/* ex.1 */
String[] strArr = {"가위", "바위", "보"};
for(int i=0; i<10; i++){
int tmp = (int)(Math.random()*3); // 0~2 임의의 정수를 얻음
System.out.println(strArr[tmp]);
}
/* ex.2 */
String[] names = {"Kim", "Park", "Yi"};
for(int i=0; i <names.length; i++) System.out.printf("names[%d]: %s%n", i, names[i]);
names[0] = "Lee";
for(String tmp : names) System.out.println(tmp);
/* 출력문
names[0]: Kim
names[1]: Park
names[2]: Yi
Lee
Park
Yi
*/
/* ex.3 16진수를 2진수로 변환하는 예제 */
char[] hex = {'C', 'A', 'F', 'E'};
String[] binary ={
"0000", "0001", "0010", "0011",
"0100", "0101", "0110", "0111",
"1000", "1001", "1010", "1011",
"1100", "1101", "1110", "1111"
};
String result ="";
for(int i=0; i<hex.length; i++){
if('0' <= hex[i] && hex[i] <= '9') result += binary[hex[i]-'0'];
else result += binary[hex[i]-'A' +10];
}
System.out.println(new String(hex)); // CAFE
System.out.println(result); // 1100101011111110
◎ String 클래스
- String 클래스 = char[] 배열 + 메서드(기능)
- String 클래스는 내용을 변경할 수 없다. (read only)
- 변경 가능한 문자열을 다루려면, StringBuffer 클래스를 사용하면 됨
// 문자열 str 의 내용이 변경되는 것 같지만, 문자열은 변경할 수 없으므로 새로운 내용의 문자열이 생성 된 것임
String str = "Java";
str += "8";
System.out.println(str); // "Java8"
String 클래스의 주요 메서드
| 메서드 | 결과 값의 값 타입 | 설명 |
| charAt(int index) | char | 문자열에서 해당 위치(index)에 있는 문자를 반환함 |
| length() | int | 문자열의 길이를 반환함 |
| substring(int from, int to) | String | 문자열에서 해당 범위 (from~to)의 문자열을 반환함 (to는 포함 안 됨) |
| equals(object obj) | boolean | 문자열의 내용이 같은지 확인한다. 같으면 true, 다르면 false |
| toCharArray() | char | 문자열을 문자배열( char[] )로 변환해서 반환함 |
예제
// ex.1 charAt(int index)
// string 클래스의 문자열을 index로 문자(char) 구하기
String str = "ABCDE";
char ch = str.charAt(3);
System.out.println(ch); // D
// ex.2 length()
// string 클래스의 문자열 길이 구하기
String str = "ABCDE";
System.out.println(str.length()); // 5
// ex.3 substring(int from, int to)
// string 클래스의 문자열의 index 범위를 이용하여 문자열 구하기
String str = "012345";
String tmp = str.substring(1,4); // str에서 index 범위 1~4의 문자들을 반환
System.out.println(tmp); // 123
// ex.4-1 equals(object obj)
// string 클래스 같나 안같나 확인. 대소문자 구별함
String str = "ABC";
String str2 = "ABC";
String str3 = "abc";
System.out.println(str.equals(str2)); // true
System.out.println(str.equals(str3)); // false
// ex.4-2 equalsIgnoreCase(object obj)
// string 클래스 같나 안같나 확인. 대소문자 구별 안함
String str = "ABC";
String str2 = "ABC";
String str3 = "aBc";
System.out.println(str.equalsIgnoreCase(str2)); // true
System.out.println(str.equalsIgnoreCase(str3)); // true
//ex.5 toCharArray()
// string 클래스 문자열을 char[] 배열로 바꾸기
String str = "ABCD";
char[] ch = str.toCharArray();
System.out.println(ch); //ABCD
char 배열과 String 클래스의 변환
char[] chArr = {'A', 'B', 'C', 'D'};
String str = new String(chArr); // char 배열 → String
char[] tmp = str.toCharArray(); // String → char 배열
/* ex.1 */
String src = "ABCDE";
for(int i=0; i<src.length(); i++){
char ch = src.charAt(i);
System.out.print(ch); // ABCDE
}
System.out.println();
char[] chArr = src.toCharArray();
System.out.println(chArr); // ABCDE
/* ex. 2*/
String source = "SOSHELP";
String[] morse = {
".-", "-...", "-.-", "-..", ".",
"..-.", "--.", "....", "..", ".---",
"-.-", ".-..", "--", "-.", "---",
".--.", "--.-", ".-.", "...", "-",
"--.."
};
String result = "";
for(int i=0; i< source.length(); i++) result += morse[source.charAt(i) - 'A'];
System.out.println(source); // SOSHELP
System.out.println(result); // ...---.........-...--.
◎ 커맨드라인 입력 받기
이클립스창에서 커맨드 라인 입력 받기
- 매개변수 입력 하는 법
- 이클립스 → Run 카테고리 → Run Configurations... → (x)= Arguments → Program arguments: → 매개변수 입력 → run
- 매개변수를 입력하지 않을 경우 참조변수 'args' 의 값은 'null' 임.
- 매개변수 입력시 공백으로 매개변수 구분함. 만약에 공백이 포함하는 문자열일경우 " " 로 구분함
/* ex.1 */
// 매개변수 입력
if(args != null){
System.out.println(args.length);
for(int i=0; i<args.length; i++) System.out.println(args[i]);
}
/* ex.2 */
// 매개변수 입력 → 123 + 235
if(args.length != 3){ // 입력된 값의 개수가 3개가 아니라면
System.exit(0); // 프로그램 종료
}
int num1 = Integer.parseInt(args[0]);
char op = args[1].charAt(0);
int num2 = Integer.parseInt(args[2]);
int result = 0;
switch(op){
case '+':
result = num1 + num2;
break;
case '-':
result = num1 - num2;
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num1 / num2;
break;
default :
System.out.println("지원되지 않는 연산입니다.");
}
System.out.println(result);
◎ 2차원 배열
- 2차원 배열의 각 요소에 접근하는 방법은 '배열이름[행index][열index]'
참고) 다차원 배열 생성시 타입에 대괄호 [ ] 를 차원의 수만큼 넣으면 됨.
참고) 행은 세로, 열은 가로
// 4행 3열의 2차원 배열 생성
int[][] score = new int[4][3]
// 값 생성
score[0][0] = 100; // score의 1행 1열에 100 저장
System.out.println(score[0][0]); // 100
// 2차원 배열의 초기화1
int[][] arr1 = new int[][] {{1,2,3}, {4,5,6}};
// 2차원 배열 초기화 2 ← 자주 쓰임
int[][] arr2 = {{1,2,3},{4,5,6}}; //new int[][] 가 생략됨
// 2차원 배열 초기화2-2 ← 이렇게 자주 쓰임
int[][] arr2 = {
{1,2,3}, // 한줄, 한줄이 1차원 배열임
{4,5,6} // 한줄, 한줄이 1차원 배열임
};
/* ex.2 */
int[][] score = new int[4][3]; // 4행 3열 2차원 배열 생성
for(int i=0; i< score.length; i++){
for(int j=0; j< socre[i].length; j++) {
score[i][j] = 10; // 배열 score의 모든 요소를 10으로 초기화
}
}
/* ex.1 */
int[][] score = {
{100, 100, 100},
{20, 20, 20},
{30, 30, 30},
{40, 40 ,40}
};
int sum = 0;
for(int i=0; i<score.length; i++){
for(int j=0; j<score[i].length; j++){
System.out.print(score[i][j] + " ");
}
System.out.println();
}
for(int[] tmp : score){ // score의 각 요소(1차원 배열 주소)를 tmp에 저장
for(int i : tmp){ // tmp는 1차원 배열을 가리키는 참조변수
sum += i;
}
}
System.out.println(sum);
/* 출력값
100 100 100
20 20 20
30 30 30
40 40 40
570
*/
/* ex.3 */
int[][] score = {
{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<score.length; i++){
//과목별 총합
korTotal += score[i][0];
engTotal += score[i][1];
mathTotal += score[i][2];
// 총점, 평균
int sum = 0;
float average = 0.0f;
// 번호
int num = i+1;
System.out.print(num);
for(int j=0; j<score[i].length; j++){
sum += score[i][j];
average = sum / score[i].length;
System.out.printf("%5d", score[i][j]);
}
System.out.printf("%5d %5.1f%n", sum, average);
}
System.out.printf("총점: %3d, %3d, %3d%n", korTotal, engTotal, mathTotal);
System.out.println("=======================================");
/* 출력값
번호 국어 영어 수학 총점 평균
=======================================
1 100 100 100 300 100.0
2 20 20 20 60 20.0
3 30 30 30 90 30.0
4 40 40 40 120 40.0
5 50 50 50 150 50.0
총점: 240, 240, 240
=======================================
*/
예제
// ex.1
int[][] score = { // 4행 3열의 2차원 배열 생성
{100, 100, 100},
{20, 20, 20},
{30, 30, 30},
{40, 40, 40}
};
int sum = 0;
for(int i=0; i < score.length; i++){ // 행 반복문
for(int j=0; j < score[i].length;j++){ // 열 반복문
System.out.printf("scre[%d][%d] =%d%n", i, j, score[i][j]);
sum += score[i][j];
}
}
System.out.println("sum = " + sum); // sum = 570
가변 배열
- 2차원 이상의 다차원 배열을 생성할 때 전체 배열 차수 중 마지막 차수의 길이를 지정하지 않고, 추후에 각기 다른 길이의 배열을 생성함으로 써 고정된 형태가 아닌 유동적인 가변 배열을 생성하는 것
// 가변 배열 생성
int[][] score = new int[5][];
score[0] = new int[4];
score[1] = new int[3];
score[2] = new int[2];
score[3] = new int[2];
score[4] = new int[3];
System.out.println(score.length); // 5
System.out.println(score[0].length); // 4
System.out.println(score[1].length); // 3
System.out.println(score[2].length); // 2
System.out.println(score[3].length); // 2
System.out.println(score[4].length); // 3
가연 배열 생성과 초기화를 동시에
int[][] score= {
{100, 100, 100, 100},
{20, 20, 20},
{30, 30},
{40, 40},
{50, 50, 50}
};
◎ 다차원 배열의 활용
- 좌표에 x 표하기
- 빙고
- 행렬의 곱셈
- 단어 맞추기
좌표에 x표 하기 ㅡ 입력한 2차원 좌표의 위치에 x표시
import java.util.Scanner;
final int SIZE = 10;
int x=0, y=0;
char[][] board = new char[SIZE][SIZE];
byte[][] shipBoard = {
// 9 * 9 테이블
// 1 2 3 4 5 6 7 8 9
{0, 0, 0, 0, 0, 0 ,0 ,0 ,0}, // 1,
{1, 1, 1, 1, 0, 0, 1, 0, 0}, // 2
{0, 0, 0, 0, 0, 0, 1, 0, 0}, // 3
{0, 0, 0, 0, 0, 0, 0, 0, 0}, // 4
{1, 1, 0, 1, 0, 0, 0, 0, 0}, // 5
{0, 0, 0, 1, 0, 0, 0, 0, 0}, // 6
{0, 0, 0, 0, 0, 1, 1, 1, 0}, // 7
{0, 0, 0, 0, 0, 0, 0, 0, 0}, // 8
{1, 0, 1, 0, 0, 1, 1, 1, 1} // 9
};
// 1행에 행번호를, 1열에 열번호를 저장함
for(int i=0; i<SIZE; i++){
board[i][0] = board[0][i] = (char)(i+'0');
}
Scanner scanner = new Scanner(System.in);
while(true){
System.out.print("좌표를 입력하세요 (종료는 00)>");
String input = scanner.nextLine();
if(input.length() == 2) {
x = input.charAt(0) - '0';
y = input.charAt(1) - '0';
if(x == 0 && y== 0) break;
}
if (input.length() !=2 || x<=0 || y<=0 || x>SIZE || y>SIZE){
System.out.println("잘못된 입력입니다. 다시 입력해주세요");
continue;
}
board[x][y] = (shipBoard[x-1][y-1] == '1') ? 'O' : 'X';
// println 메서드로 1차원 char 뱌ㅐ열의 참조변수를 출력하면, 배열의 모든 요소를 한 줄로 출력함
for(int i=0; i<SIZE; i++) System.out.println(board[i]); // board[i]는 1차원 배열임
System.out.println();
} end of while
빙고
import java.util.Scanner;
final int SIZE = 5;
int x=0, y=0, num=0;
int[][] bingo = new int [SIZE][SIZE];
// 빙고 배열에 값 저장하기
for(int i=0; i<SIZE; i++){
for(int j=0; j<SIZE; j++) bingo[i][j] = i*SIZE + j + 1;
}
// 빙고 배열에 있는 값 랜덤을 섞기
for(int i=0; i<SIZE; i++){
x = (int)(Math.random()*SIZE);
y = (int)(Math.random()*SIZE);
for(int j=0; j<SIZE; j++){
int tmp = bingo[i][j];
bingo[i][j] = bingo[x][y];
bingo[x][y] = tmp;
}
}
do{
// 빙고판 보여주기
for(int i =0; i<SIZE; i++){
for(int j=0; j<SIZE; j++){
System.out.printf("%2d ",bingo[i][j]);
}
System.out.println();
}
System.out.println();
// 빙고 맞추기
System.out.printf("1~ %d 까지 숫자를 입력하세요 (종료:0)>", SIZE*SIZE);
Scanner scanner = new Scanner(System.in);
String tmp = scanner.nextLine();
num = Integer.parseInt(tmp);
// 맞춘 빙고판의 숫자를 0 으로 표시하기
outer:
for(int i=0; i<SIZE; i++){
for(int j=0; j>SIZE; j++){
if(bingo[i][j] == num){
bingo[i][j] = 0;
break outer;
} // end of if
} // end for j
} // end for i
} while (num !=0); // 0 누르면 종료
행렬의 곱셈
- 두 행렬의 곱셈이 가능하려면 행렬 A의 열의 길이와 행렬 B의 행의 길이가 일치해야함
- A*B = m행 n열
int[][] m1= { // 2*3 행렬
{1,2,3},
{4,5,6}
};
int[][] m2 ={ // 3*2 행렬
{1,2},
{3,4},
{5,6}
};
final int ROW = m1.length; // m1 행의 길이 : 2
final int COL = m2[0].length; // m2 열의 길이 : 2
final int M2_ROW = m2.length; // m2 행의 길이 : 3
// m3 행렬 생성하기
int[][]m3 = new int[ROW][COL];
// m1 x m2 행렬 곱하기
for(int i=0; i<ROW; i++){
for(int j=0; j<COL; j++){
for(int k=0; k<M2_ROW; k++) m3[i][j] += (m1[i][k] * m2[k][j]);
} // end for i
} // end for j
// m3 행렬 출력
for(int i=0; i<ROW; i++){
for(int j=0; j<COL; j++) System.out.printf("%3d", m3[i][j]);
System.out.println();
}
/* 출력
22 28
49 64
*/
단어 맞추기
import java.util.Scanner;
String[][] words = {
{"chair", "의자"},
{"computer", "컴퓨터"},
{"integer", "정수"}
};
// 단어 맞추기
for(int i=0; i<words.length;i++){
System.out.printf("Q%d %s의 뜻은?", i+1, words[i][0]);
Scanner scanner = new Scanner(System.in);
String tmp = scanner.nextLine();
if(words[i][1].equals(tmp)){
System.out.printf("정답입니다.%n%n");
} else {
System.out.printf("틀렸습니다. 정답은 %s입니다.%n%n", words[i][1]);
};
}◎ Array 배열 다루기
배열의 비교와 출력
- Arrays.equals() ㅡ 1차원 배열 비교
- Arrays.deepEquals() ㅡ 2차원, 다차원 배열 비교
- Arrays.toString() ㅡ 1차원 배열을 문자열로 반환
- Arrays.deepToString() ㅡ 2차원, 다차원 배열을 문자열로 반환
// ex.1 배열을 문자열로 반환하기
import java.util.Arrays;
int[] arr = {0,1,2,3,4};
int[][] arr2D= {{11,12}, {21,22}};
// 1차원 배열일 때 문자열로 반환하기
System.out.println(Arrays.toString(arr)); // [0, 1, 2, 3, 4]
// 2차원배열, 다차원 배열일 때 문자열로 반환하기
System.out.println(Arrays.deepToString(arr2D)); // [[11, 12], [21, 22]]
// ex.2 1차원 배열 비교하기
import java.util.Arrays;
String[] str = {"1","2","3","4","5","6"};
String[] str2 = {"1","2","3","4", "5","6"};
String[] str3 = {"2","3","4","5","6"};
System.out.println(Arrays.equals(str, str2)); // true
System.out.println(Arrays.equals(str, str3)); // false
// ex.3 2차원, 다차원 배열 비교하기
String[][] str2D = {{"aaa", "bbb"}, {"AAA", "BBB"}};
String[][] str2D2 = {{"aaa", "bbb"}, {"AAA", "BBB"}};
String[][] str2D3 = {{"AAA", "BBB"}, {"aaa", "bbb"}};
System.out.println(Arrays.deepEquals(str2D, str2D2)); // true
System.out.println(Arrays.deepEquals(str2D, str2D3)); // false
배열의 정렬
- Arrays.sort(배열명) ㅡ 오름차순 정렬
// ex.1 Arrays.sort()
int[] arr = {3, 2, 0, 1, 4};
Arrays.sort(arr); // 배열 정렬
System.out.println(Arrays.toString(arr)); // [0,1,2,3,4]728x90