티스토리 뷰

 

 

 

 

 

 

 

 

 

 

📍   배열 (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점

 

 

 

 

 

 

 

 

 

 

댓글
공지사항
최근에 올라온 글
최근에 달린 댓글
Total
Today
Yesterday
링크
«   2025/06   »
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
글 보관함