[java] 6. 배열(Array)

1. 배열(Array)의 개념

basic > ArrayApp.java

 

1) 배열의 개념

• 같은 자료형의 값을 여러개 저장하기 위한 메모리를 할당받기 위한 자료형(=참조자료형)
• 힙영역에 만들어짐 (no name, 스택영역에 만들어지는 참조변수통해 접근하기)

 

2) 배열의 필요성

• 변수는 값을 1개만 저장할 수 있지만, 배열은 값을 여러개를 저장할 수 있음
• 값을 여러개를 저장하여 일괄처리를 목적으로 사용 (일괄처리를 하지 않으려면 배열을 쓸 가치가 없음)
• 데이터를 한꺼번에 처리한다 = 계산과 출력을 한꺼번에 한다

데이터 처리방법의 2가지

• 일괄처리 : 데이터를 한꺼번에 모아놨다가 처리하는 것
  ex. 신용카드, 통계프로그램(데이터를 모아놓고 한꺼번에 처리)
• 실시간처리 : 데이터를 입력받자마자 처리하는 것(RealTime Process)
  ex. 은행의 입출금처리

 

3) 배열의종류

• 👻데이터하나 : like 점 (그동안 우리가 사용했던 원시형 데이터들)
• 👻1차원배열 : like 선 (다수의 값을 저장하기 위한 자료형)
• 👻다차원배열
  2차원배열 : like 면 ( 다수의 배열을 저장하기 위한 자료형 )
  3차원배열 : like 공간 (다수의 1차원배열을 저장하기 위한 자료형)
  4차원배열 : 시공간.. (현실세계에 존재하지 않으므로 프로그램으로 구현불가능ㅜ)

 

 

 

 

2. 1차원 배열

Example > ArrayExample.java

• 1차원 배열을 생성하여 참조변수에 생성된 배열의 메모리 주소(Hash Code)를 저장 (vs C언어 pointer)

 

1) 형식

형식1) 참조변수선언과 배열생성을 함께

자료형[] 참조변수 = new 자료형[갯수];  //자바스러운
자료형 참조변수[] = new 자료형[갯수];  //c언어스러운


//자료형[] : 1차원 배열에 대한 자료형

//자료형[] 참조변수 : 1차원 배열의 메모리 주소를 저장하기 위한 참조변수 생성 
// => 지역변수라면 stack영역에 (참조변수)생성

//new 자료형[갯수] : 자료형의 값을 갯수만큼 저장 가능한 배열 생성 
// => heap메모리에 배열 생성

 

형식2) 참조변수선언 후 배열생성

자료형[] 참조변수;
참조변수 = new 자료형[갯수];

 

2) 예제

//1.
//1차원 배열을 생성하여 참조변수에 저장
int[] num = new int[3];
//참조변수에 저장된 값을 "자료형@메모리주소" 형식으로 제공받아 출력
System.out.println("num = "+num); // num = [I@7d6f77cc

//2.
int[] num;
System.out.println("num = "+num); //error

//3. 참조변수(stack)는 자동초기화가 안되므로 출력하고 싶으면 null 할당하기
int[] num = null;
System.out.println("num = "+num); //num = null


//  [I : integer 1차원배열
//  @7d6f77cc : 메모리주소(hashcode)

//stack영역 : int[] num참조변수 생성
//heap메모리 : new int[3]배열 생성

 

3) 1차원 배열의 요소(element)

• 1차원 배열은 다수의 값을 저장하기 위한 요소(Element)의 모임
• 배열의 요소는 첨자(Index: 0 부터 1씩 증가되는 정수값)를 이용하여 구분함
• vs 유일한 인덱스 1부터 시작하는 언어 : oracle에서 사용하는 SQL의 인덱스

 

4) 자동 초기화

• 생성된 배열의 요소에는 기본값이 초기값으로 자동 저장
• 요소의 기본값 : [논리형 : false] [숫자형: 0] [참조형: null]

 

5) 자동 초기화 예제

//자바에서는 new 연산자를 사용하여 메모리를 사용하면 자동으로 기본값이 들어감
int[] num = new int[3];

//참조변수와 배열의 요소를 구분하는 첨자를 사용하여 배열 요소에 접근하여 사용
//형식)참조변수[첨자] - 배열의 요소를 표현하는 방법
System.out.println("num[0] = "+num[0]);//요소값 출력
System.out.println("num[1] = "+num[1]);
System.out.println("num[2] = "+num[2]);
//num[0] = 0
//num[1] = 0
//num[2] = 0

 

 

6) 1차원 배열의 예외발생

• 배열의 요소를 구분하는 첨자를 잘못사용하는 경우 예외 발생
• 예외가 발생된 경우 프로그램은 그 즉시 강제 종료됨
• 나중에 예외를 다루는 방법을 배움

예외발생 예제

//예외클래스의 종류는 매우 많다! - MisMatchException, ArrayIndexOutOfBoundsException, NullpoinException 등
//예외메세지 :
//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
//at basic.ArrayApp.main(ArrayApp.java:36)

int[] num = new int[3];
System.out.println("num ="+num)
//num =[I@7d6f77cc
System.out.println("num[0] = "+ num[0]);
System.out.println("num[1] = "+ num[1]);
System.out.println("num[2] = "+ num[2]);

//배열의 요소를 구분하는 첨자를 잘못사용하는 경우 예외 발생
//(ArrayIndexOutOfBoundsException)
System.out.println("num[3] = "+ num[3]);  //Exception
//아래에 println메소드는 실행안됨
System.out.println("================================================");

 

 

7) 배열 요소의 갯수 확인하기

//참조변수에 저장된 배열 요소의 갯수를 표현하는 형식
참조변수.length

int[] num = new int[3];
System.out.println("배열 요소의 갯수 =" + num.length);
//배열 요소의 갯수 =3

 

 

8) 배열 요소를 구분하는 첨자는 변수 또는 연산식으로 표현 가능

int index=0;
num[index]=10;//요소값 변경
num[index+1]=20;
num[index+2]=30;
System.out.println("num[0] = "+num[0]);
System.out.println("num[1] = "+num[1]);
System.out.println("num[2] = "+num[2]);
//num[0] = 10
//num[1] = 20
//num[2] = 30

 

 

9) 원하는 초기값을 넣어 배열 생성

배열 생성 시 배열 요소에 기본값 대신 원하는 초기값 저장 가능

 

🍄일반형 형식

• 블럭{} 안에 나열된 초기값의 갯수만큼의 요소를 가지고 있는 배열 생성
• 힙 영역에 만들어짐

자료형[] 참조변수 = new 자료형[] {초기값1, 초기값2, 초기값3... };

//예제1.
int[] su1 = new int[] {10, 20, 30};

//예제2. 가능하다!
int[] su1;
su1 = new int[] {10, 20, 30}; 

//예제3.
int[] su1 = new int[] {10, 20, 30};
for(int i=0; i<num.length; i++) {
	System.out.println("su1["+i+"] = "+su1[i]);
}
//su[0] = 10
//su[1] = 20
//su[2] = 30

 

🍄간편형 형식

• 블럭{} 안에 초기값을 나열하여 배열 생성
• 간단한 대신 여러가지 제약이 있음
• 상수를 표현하는 영역에 만들어짐 - 상수객체
• 일반형 형식과 만들어지는 영역 자체가 다름

자료형[] 참조변수 = {초기값, 초기값, 초기값 ...};

//예제1.
int[] su2 = {10, 20, 30};

//예제2. 불가능하다!
//참조변수 생성 후 배열 생성 불가능
int[] su2;
su2 = {10, 20, 30}; //error

 

 

10) [배열의 일괄처리] for구문

for구문을 사용하여 배열 요소에 대한 일괄 처리

• for 구문의 초기식, 조건식, 증감식에서 사용하는 변수로 첨자 표현하여 일괄 처리
• 즉, 입력 , 계산 , 출력 모든 명령들을 일괄처리가 가능하다

int[] num = new int[3];

System.out.println("num ="+num)
//num =[I@7d6f77cc

/*
System.out.println("num[0] = "+ num[0]);
System.out.println("num[1] = "+ num[1]);
System.out.println("num[2] = "+ num[2]);
//num[0] = 0
//num[1] = 0
//num[2] = 0
*/

//일괄처리로 출력
for(int i=0; i<num.length; i++) {
	System.out.println("num["+i+"] = "+num[i]);
}
//num[0] = 10
//num[1] = 10
//num[2] = 10

 

11) [배열의 일괄처리] 향상된 for구문

배열을 일괄처리하기 위한 변형된 for 구문

• 계산하고 출력할 때 이용
• 참조변수에 저장된 배열의 요소값을 커서(cursor)를 이용해 차례대로 제공받아 변수에 저장하여 반복 처리
• 내부에 커서가 있어서 커서가 이동하면서 배열의 요소를 하나씩 제공받다가 커서 위치에 더 이상 요소가 없다면 반복문 종료됨
• 즉, 배열의 모든 요소값을 제공받은 후에 반복문 종료 - (반복문이지만, 조건이 없음)

//향상된 for 구문이 왜 좋을까?
//=> 배열의 요소를 구분하는 인덱스를 잘못쓰면 예외가 발생하는 대신 <향상된 for 구문>은 예외없이 이용 가능
//=> 요소값들을 일괄처리하여 출력할 때 사용 많이하므로 매우매우 중요함!!!

//향상된 for 구문의 제약조건
//=> 입력처리 불가능: 즉, 몇번째 위치에 다른 값으로 저장 불가능
//=> 대상의 출력만 가능 : 값을 읽을 수만 있음

//형식
for(자료형 변수명:참조변수){명령; 명령; ...}


//예제1.
int[] su2 = {10, 20, 30};
for(int temp:su2) {
	System.out.println(temp);
}
//10
//20
//30



//예제2. 배열의 모든 요소들의 값에 대한 합계를 계산하여 출력
int[] array = {54,70,64,87,96,21,65,76,11,34,56,41,77,80};
/*
//for구문
int tot=0;
for(int i=0;i<array.length;i++) {
	tot+=array[i];
}
System.out.println("합계 = "+tot);
//합계 = 832
*/

//향상된 for구문
int tot=0;
for(int element:array) {
	tot += element;
}
//합계 = 832


//예제3. 배열의 요소값이 30~60 범위의 정수값인 요소의 갯수를 계산하여 출력
int[] array = {54,70,64,87,96,21,65,76,11,34,56,41,77,80};
int count=0;
for(int element:array) {
	if(element>=30 && element<=60) {
		count++;
	}
}
System.out.println("30~60 범위의 요소 갯수 = "+count);
//30~60 범위의 요소 갯수 = 4

 

12) 1차원 배열의 예제

배열에 저장된 모든 사람들이 나이 평균을 계산하여 출력

(단, 배열에 저장된 사람들의 나이를 연령별로 구분하여 인원수를 계산하여 출력)

package example;
//ex) 10대 = 3명
//20대 = 4명
//...
//60대 = 2명
public class ArrayExample {
	public static void main(String[] args) {
		//사람들의 나이를 저장한 배열 생성하여 참조변수에 저장		
		int[] age={27,16,22,36,57,60,43,23,14,29,44,52,59,51,39,33,11};
		
		//배열에 저장된 모든 사람들의 나이 평균을 계산하여 출력하세요.
		int tot=0;
		for(int nai:age) {
			tot+=nai;
		}
		
		System.out.println("평균 나이 = "+(tot/age.length)+"살");
		System.out.println("===============================================================");
		//배열에 저장된 사람들의 나이를 연령별로 구분하여 인원수를 계산하여 출력하세요.
		//ex) 10대 = 3명
		//    20대 = 4명
		//    ...
		//    60대 = 1명


		/*
		int cnt10=0, cnt20=0, cnt30=0, cnt40=0, cnt50=0, cnt60=0;
		
		for(int nai:age) {
			if(nai>=10 && nai<=19) cnt10++;
			else if(nai>=20 && nai<=29) cnt20++;
			else if(nai>=30 && nai<=39) cnt30++;
			else if(nai>=40 && nai<=49) cnt40++;
			else if(nai>=50 && nai<=59) cnt50++;
			else if(nai>=60 && nai<=69) cnt60++;
		}
		
		System.out.println("10대 = "+cnt10+"명");
		System.out.println("20대 = "+cnt20+"명");
		System.out.println("30대 = "+cnt30+"명");
		System.out.println("40대 = "+cnt40+"명");
		System.out.println("50대 = "+cnt50+"명");
		System.out.println("60대 = "+cnt60+"명");
		*/
		
		//연령별 인원수 카운트할 배열 생성하면 0으로 자동초기화됨
		int[] cnt=new int[6];//연령별 인원수를 저장하기 위한 배열 생성
		
		for(int nai:age) {
			/*
			if(nai>=10 && nai<=19) cnt[0]++;
			else if(nai>=20 && nai<=29) cnt[1]++;
			else if(nai>=30 && nai<=39) cnt[2]++;
			else if(nai>=40 && nai<=49) cnt[3]++;
			else if(nai>=50 && nai<=59) cnt[4]++;
			else if(nai>=60 && nai<=69) cnt[5]++;
			*/
			
			/*
			switch (nai/10) {
			case 1: cnt[0]++; break;
			case 2: cnt[1]++; break;
			case 3: cnt[2]++; break;
			case 4: cnt[3]++; break;
			case 5: cnt[4]++; break;
			case 6: cnt[5]++; break;
			}
			*/
			
			cnt[nai/10-1]++;
		}
		
		for(int i=0;i<cnt.length;i++) {
			System.out.println((i+1)*10+"대 = "+cnt[i]+"명"); //첨자를 구하는 규칙을 찾는다면 효과적인 프로그램 만들 수 있음
		}	
		System.out.println("===============================================================");
	}
	
}
//평균 나이 = 36살
//===================================================
//10대 = 3명
//20대 = 4명
//30대 = 3명
//40대 = 2명
//50대 = 4명
//60대 = 1명

 

 

 

3. 2차원 배열

basic > DoubleArrayApp.java

• 2차원배열 : 1차원배열의모임

1) 형식

• 행갯수 : 2차원 배열에 저장되는 1차원 배열의 갯수
• 열갯수 : 1차원 배열에 저장되는 요소(Element)의 갯수

자료형[][] 참조변수 = new 자료형 참조변수[행갯수][열갯수];

 

2) 2차원 배열의 예제

int[][] num = new int[2][3];

System.out.println("num = " + num);
//num = [[I@7d6f77cc

System.out.println("num[0] = " + num[0]);
System.out.println("num[1] = " + num[1]);
//num[0] = [I@5aaa6d82
//num[1] = [I@73a28541

System.out.println("num[0][0] = " + num[0][0]);
System.out.println("num[0][1] = " + num[0][1]);
System.out.println("num[0][2] = " + num[0][2]);
//num[0][0] = 0
//num[0][1] = 0
//num[0][2] = 0

System.out.println("num[1][0] = " + num[1][0]);
System.out.println("num[1][1] = " + num[0][1]);
System.out.println("num[1][2] = " + num[0][2]);
//num[1][0] = 0
//num[1][1] = 0
//num[1][2] = 0

 

3) 2차원 배열의 길이

System.out.println("num.length = "+num.length);//1차원 배열의 갯수
System.out.println("num[0].length = "+num[0].length);//1차원 배열의 요소 갯수
System.out.println("num[1].length = "+num[1].length);
//num.length = 2
//num[0].length = 3
//num[1].length = 3

 

4) 원하는 초기값을 넣어 배열 생성

🍄일반형 형식

int[][] su=new int[][] {{10,20,30},{40,50,60},{70,80,90}};

🍄간편형 형식

int[][] su={{10,20,30},{40,50,60},{70,80,90}};

 

5) 2차원 배열은 "중첩 for문" 이용하여 출력가능

for(int i=0;i<num.length;i++) {//행처리 : 1차원 배열의 갯수만큼 반복 처리
	for(int j=0;j<num[i].length;j++) {//열처리 : 1차원 배열의 요소 갯수만큼 반복 처리
		System.out.print(num[i][j]+"  ");
	}
	System.out.println();
}
//0  0  0
//0  0  0

 

 

6) 향상된 for문 이용해 출력 (+ with 중첩for문)

int[][] su={{10,20,30},{40,50,60},{70,80,90}};

for(int[] array:su) {
	for(int number:array) {
		System.out.print(number+"  ");
	}
	System.out.println();
}
//10  20  30
//40  50  60
//70  80  90

 

7) 2차원 배열 생성(1차원 배열 없음)

//1차원 배열의 메모리 주소를 저장할 수 있는 참조요소만 생성
//2차원의 배열의 참조요소에는 null 저장
int[][] value=new int[3][];
System.out.println("value = "+value); //value = [[I@6f75e721
System.out.println("value[0] = "+value[0]); //value[0] = null
System.out.println("value[1] = "+value[1]); //value[1] = null
System.out.println("value[2] = "+value[2]); //value[2] = null

 

8) 2차원 배열 생성(2차원 배열의 참조요소에 1차원 배열을 생성해 저장)

//1차원 배열의 요소의 갯수를 다르게 생성하여 저장 가능 - 가변배열
//가변배열을 만드는 이유: 메모리절약
int[][] value=new int[3][];
value[0]=new int[3];
value[1]=new int[2];
value[2]=new int[4];
System.out.println("value[0] = "+value[0]); //value[0] = [I@69222c14
System.out.println("value[1] = "+value[1]); //value[1] = [I@606d8acf
System.out.println("value[2] = "+value[2]); //value[2] = [I@782830e
int[][] doubleArray={{10,20,30},{40,50},{60,70,80,90}};//가변배열
for(int[] array:doubleArray) {
	for(int number:array) {
		System.out.print(number+"  ");
	}
	System.out.println();
}
//10  20  30
//40  50
//60  70  80  90

 

9) 내가 만든 예제

int[][] doubleArr = new int[2][6];
doubleArr[0] = new int[] {0,20,30,40,50,60};
doubleArr[1] = new int[] {70,80,90,100,110,120};
for(int[] row:doubleArr) {
	for(int element:row) {
		System.out.print(element + " ");
	}
	System.out.println();
}
//0 20 30 40 50 60
//70 80 90 100 110 120

 

10) 1~45 범위의 난수를 6개 제공받아 출력하는 프로그램

basic > LottoApp.java

package basic;

// => 6개 난수는 서로 중복되지 않도록 작성하며 오름차순 정렬하여 출력
//정렬(Sort) : 값을 순서대로 나열하는 기능 - 오름차순 정렬(AscendingSort), 내림차순 정렬(DescendingSort)
public class LottoApp {
	public static void main(String[] args) {

		//1.
		//6개의 정수난수를 저장하기 위한 배열 선언
		int[] lotto=new int[6];
		
		//2.
		//1~45 범위의 정수난수를 6개 제공받아 배열 요소에 차례대로 저장
		// => 중복된 난수값이 아닌 경우에만 배열 요소에 저장
		for(int i=0;i<lotto.length;i++) {//새로운 난수값을 저장하는 배열 요소의 첨자 표현

			//요소에 저장된 새로운 난수값을 기존 요소의 난수값과 모두 비교하여 같은 값이 있는 반복문을 이용하여 새로운 난수값을 제공받아 배열 요소에 저장
			// => 새로운 난수값이 기존 요소의 난수값과 다른 경우 반복문 종료

			while(true) {//정상적인 값이 입력된 경우 반복문 종료 - 입력값 검증

				
				lotto[i]=(int)(Math.random()*45)+1;//1~45범위의 난수를 제공받아 배열 요소에 저장
				boolean result=false;//중복상태를 저장하기 위한 변수 - false : 미중복, true : 중복
				
				//새로운 난수값을 기존 배열 요소의 난수값과 비교
				for(int j=0;j<i;j++) {//기존 난수값이 저장된 배열 요소의 첨자 표현 
					if(lotto[i]==lotto[j]) {//lotto[i] : 새로운 난수값, lotto[j] : 기존 난수값
						result=true;
						break;//fo문 종료
					}
				}
				
				//새로운 난수값이 기존 난수값과 비교하여 중복되지 않은 경우 반복문 종료
				if(!result) break;//while문 종료
			}
		}
		
		//3.
		//배열의 모든 요소값을 서로 비교하여 오름차순 정렬되도록 배열 요소값을 바꾸어 저장
		// => 선택 정렬 알고리즘(Selection Sorting Algorithm) 사용
		for(int i=0;i<lotto.length-1;i++) {//비교 요소의 첨자 표현 : 처음 ~ 끝-1
			for(int j=i+1;j<lotto.length;j++) {//피비교 요소의 첨자 표현 : 비교+1 ~ 끝
				if(lotto[i]>lotto[j]) {//lotto[i] : 비교 요소, lotto[j] : 피비교 요소
					//비교한 요소의 값을 서로 바꾸어 저장
					int temp=lotto[i];
					lotto[i]=lotto[j];
					lotto[j]=temp;
				}
			}
		}
		
		//4.
		//배열의 모든 요소값 출력
		System.out.print("행운의 숫자 >> ");
		for(int number:lotto) {
			System.out.print(number+" ");
		}
		System.out.println();
	}
}