[JAVA] 12. 배열

 배열(array)

- 같은 타입의 데이터 여러 개를 하나의 묶음(변수)으로 다루는 메모리 공간

 

[ 특징 ]

1. 같은 타입 데이터만 저장 가능
2. 여러 변수에 해당하는 메모리 공간이 연속된 공간에 차례대로 생성됨 -> 한 번 생성된 배열은 크기 변경 불가능!
3. 기본 데이터타입과 참조 데이터타입 모두 배열로 사용 가능
4. 배열은 선언, 생성, 초기화의 3단계 과정을 거쳐서 사용
5. 배열 생성 시 각 공간에 해당하는 인덱스(번호)가 자동으로 부여됨 -> 0부터 시작하여, 배열 크기 -1까지 부여됨
6. 배열이 생성될 경우 배열의 데이터 저장 공간은 배열의 데이터타입에 해당하는 기본값으로 자동으로 초기화
(Byte, short, int = 0, long = 0L, float = 0.0f, double = 0/0, char =0 또는 '\u0000', boolean = false, String = null)
7. 배열의 이름(변수명)을 사용하여 배열에 접근 가능(인덱스 필요)
8. 배열의 크기는 배열명.length 속성을 통해 알아낼 수 있음

 

 

< 배열의 선언 기본 문법 >

데이터타입[] 변수명;
-> 변수 선언과 유사하나, 데이터타입 뒤에 []기호를 붙여 배열 표시
-> 배열 공간이 생성되기 전이므로, 아직 데이터 저장은 불가

-> 선언된 배열의 변수는 참조형 변수로 취급됨 (주의! int는 기본형이지만, int[]은 참조형)

 

< 배열의 생성 기본 문법 >

변수명 = new 데이터타입[배열 크기];
-> new 키워드를 사용하여 배열 공간을 생성하는데 데이터타입 뒤의 대괄호 안에 생성할 배열의 크기를 명시
-> 생성되는 배열의 위치(주소값)를 선언된 배열 타입 변수에 저장
-> 이제, 실제 메모리 공간이 생성되었으므로 데이터 저장이 가능
-> 생성된 배열에는 자동으로 인덱스 번호가 부여됨 (인덱스 번호는 0~ 배열크기 -1까지 자동으로 부여됨)

 

 

< 배열 선언 및 생성을 하나의 문장으로 결합 >

데이터타입[] 변수명 = new 데이터타입[배열 크기];

 

< 배열 접근 기본 문법 >

변수명[인덱스]
-> 변수명에 해당하는 주소(배열 공간)에 접근한 뒤 인덱스에 해당하는 데이터 저장 공간에 접근
-> 배열에 데이터 초기화(저장)시
변수명[인덱스] = 데이터;

 

< 반복문을 통하여 배열의 모든 인덱스 접근 기본 공식 >

for(int i =0; i < 배열명.length; i++){
      // 배열명[i] 형태로 접근
 }

 

// 학생 점수 5개를 별도의 변수에 저장하고 관리하는 경우
		int score1 = 90, score2 = 60, score3 = 80, score4 = 100, score5 = 50;
		int scoreTotal = score1 + score2 + score3 + score4 + score5;
		// ----------------------------------------------------------
		
		// 학생 점수 5개(정수)를 저장한 배열(score) 선언 및 생성, 초기화
		// 1. 배열 선언: 데이터타입[] 배열명;
		// int[] score; // int형 정수 여러개를 저장할 배열 score를 선언
		// -> 아직 데이터를 저장할 수 있는 메모리 공간은 생성되기 전
		// score = 90; // 오류 발생! 배열 이름으로 사용되는 변수에 데이터 저장 불가!

 

 

		// 2. 배열 생성: 변수명(배열명) = new 데이터타입[배열크기];
		// score = new int[5];
		// 연속적인 int형 배열 공간 5개를 생성하고,
		// 해당 공간의 메모리 주소를 int[] 타입 변수 score에 저장
		// -> 이 때, 5개의 메모리 공간에는 각각의 인덱스 번호가 자동으로 부여됨
		//    (인덱스 번호는 0~4까지 부여됨)
		
		// 배열 선언 및 생성을 하나의 문장으로 결합
		int[] score = new int[5];
		
		// 배열에 접근하여 각 배열 공간의 데이터 출력
		// -> 배열명이 score이므로 score[인덱스] 형식으로 접근
		// System.out.println(score); // 배열명 그대로 출력 시 주소값 출력(데이터X)
		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번 인덱스 데이터 값 출력
		// -> 이때, 배열은 자동으로 기본값으로 초기화되므로 0 출력됨
		
		/*
		 * 주의! 생성된 배열의 인덱스 범위를 벗어나는 배열 접근 시 오류 발생!
		 * -> 단, 문법적으로 오류가 아니기 때문에 코드 상에서는 알 수 없고,
		 *    프로그램 실행 시점에서 오류가 발견됨
		 */
		// System.out.println(score[5]); // 실행 시 오류 발생!

		// 배열에 데이터 저장(초기화) -> 90, 60, 80, 100, 50
		score[0] = 90;
		score[1] = 60;
		score[2] = 70;
		score[3] = 100;
		score[4] = 50;
		// score[10] = 100; // 존재하지 않는 인덱스 접근. 실행 시 오류 발생!
		
		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번 인덱스 데이터 값 출력

		// for문을 사용하여 배열 인덱스 범위(0~4)까지 반복하면서
		// 출력문을 통해 배열 인덱스에 차례대로 접근하여 데이터 출력
		for(int i=0; i < 5;i++) { // for(int i = 0 ; i <= 4; i++)
			// -> 0 ~ 4까지 1씩 증가하는 제어변수 i를 인덱스 번호로 활용 가능
			System.out.println(score[i]); // score[0] ~ score[4]까지 대응
		}
		// -> 배열의 모든 인덱스 접근 시 조건식에 배열 크기 직접 지정할 경우
		//    배열 크기가 변경되면 조건식 코드도 다시 변경해야 한다!

		// 배열명.length 속성을 사용하여 배열의 크기(길이)를 알아낼 수 있다!
		System.out.println("배열 score의 크기: " + score.length);
		// 배열의 크기값을 반보문의 조건식에 활용하면
		// 배열 크기가 변경되더라도 동적으로 대응 가능

		// 배열 전체 접근 시 기본 공식을 사용하여 배열 데이터 모두 출력
		for(int i =0; i < score.length; i++) {
			// System.out.println(score[i]); // score[0] ~ [4]까지 대응
			System.out.println(i + "번 인덱스: " + score[i]);
		}

		// 배열 선언 시 [] 기호 위치에 따른 차이점
		int[] arr1, arr2; // arr1, arr2 모두 int[] 타입 변수로 선언됨
		int arr3, arr4[]; // arr3은 int, arr4는 int[] 타입 변수로 선언됨
		// -> 따라서, 자바에서 추천하는 문법(데이터타입 뒤 [] 명시) 사용 권장

 

 

TEST

		// int형 배열 공간 5개를 생성(arr) 하고 임의의 정수 5개로 초기화 한 출력
		// int[] arr;
		// arr = new int[5];
		int[] arr = new int[5];
		
		arr[0] = 10; // 컨 + 알 + ↓ : 한 줄 복사, 알트 + 방향키: 줄 이동
		arr[1] = 20;
		arr[2] = 30;
		arr[3] = 40;
		// arr[4] = 50; 초기화 하지 않을 경우 4번 인덱스는 0으로 자동 초기화됨
		
		for(int i =0; i <arr.length; i++) {
			System.out.println(i + "번 인덱스 데이터: "+arr[i]);
		}

 

		// boolean 타입 배열 3개 생성하고
		// 임의의 boolean 타입 데이터 초기화 후 출력
		// 2번 인덱스만 true 값으로 초기화
		
		boolean[] arr2 = new boolean[3];
		arr2[2] = true;
		
		// 0번, 1번 인덱스를 초기화하지 않을 경우 기본값 false로 자동으로 초기화
		
		for(int i =0; i <arr2.length; i++) {
			System.out.println(i + "번 인덱스 데이터: "+arr2[i]);
		}

 

		// String 타입 배열 3개를 생성하고
		// 0번 "홍길동", 1번 "이순신" 문자열로 초기화한 후 출력
		
		String[] arr3 = new String[3];
		arr3[0] = "홍길동";
		arr3[1] = "이순신";
		
		for(int i =0; i <arr3.length; i++) {
			System.out.println(i + "번 인덱스 데이터: "+arr3[i]);
		}

		// double 타입 데이터 5개를 저장하는 배열 arr4 생성 후
		// 임의의 4개의 실수로 초기화 후 전체 데이터 차례대로 출력
		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(i + "번 인덱스 데이터 :" + arr4[i]);			
		}

 

 

 

 < 배열 선언, 생성, 초기화를 한꺼번에 수행하는 문법 >

데이터타입[] 변수명 = {데이터1, 데이터2, ...., 데이터n};
=> 배열 생성 문법을 별도로 명시하지 않고
중괄호를 사용하여 초기화할 데이터를 리터럴 형태로 전달하면 해당 데이터 개수만큼 배열 공간이 자동으로 생성됨
=> n개 만큼의 공간을 생성하면서 인덱스 번호가 0 ~ n-1까지 부여되고 자동으로 기본값으로 초기화 됨

//		int[] arr = new int[5];
//		arr[0] = 1;
//		arr[1] = 2;
//		arr[2] = 3;
//		arr[3] = 4;
//		arr[4] = 5;
		
		// 위의 문장들을 하나로 결합하여 리터럴로 즉시 초기화까지 수행
		int[] arr = {1, 2, 3, 4, 5};
		// => 주의! 5개의 리터럴 저장 시 5개 데이터 저장 공간만 생성되므로
		//    추가적인 데이터 저장은 불가능하게 된다!
		
		// 배열 arr의 모든 요소 출력
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}

// int형 배열 arr2를 먼저 선언한 후
		// 별도로 정수형 리터럴 1,2,3,4,5로 한꺼번에 초기화하는 경우
		int[] arr2;
//		arr2 = new int[5];
//		arr2 = {1,2,3,4,5}; // 오류 발생! 별도로 초기화 시 사용 불가능!
		// -> new 키워드를 사용하는 방법과 결합하여 문법을 지정해야 함
		arr2 = new int[] {1,2,3,4,5};
		// -> 주의! 배열 크기는 지정하지 않도록 한다!
		
		System.out.println("-------------------------");
		
		// String 타입 문자열 데이터 3개 ("JAVA", "JSP", "CLOUD")를 저장하는
		// 배열 strArr을 생성하고 리터럴로 즉시 초기화까지 수행 후 출력
		String[] strArr = {"JAVA", "JSP", "CLOUD"};
		for(int i = 0; i<strArr.length; i++) {
			System.out.println(strArr[i]);
			
		}

		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 저장 공감의 주소값을 전달받아 참조하게 됨
		// 이때, 기존 1,2,3 저장 공간은 더 이상 참조되지 않으므로
		// 불필요한 메모리 공간이 되어 Garbage Collector에 의해 정리 대상 됨
		// -> 즉, 더 이상 필요 없는 메모리 공간은 자동으로 정리됨
		
		b = c; // c의 주소값을 b에 저장
		// 기존에 b가 참조하던 4,5,6 저장 공간을 버리고
		// c가 가리키던 7,8,9 저장 공간의 주소값을 전달받아 참조
		// 이때, 기존 4,5,6 저장 공간은 여전히 a 에 의해서 참조되고 있으므로
		// Garbage colletor에 의한 정리 대상이 아니다!

 

 

 

TEST

		/*
		 * 배열의 최대값을 구하는 코드
		 * numbers = { 3, 2, 14, 21, 100, 4, 2, 1 }
		 * int max; int min; int sum; int avg;
		 * 
		 * 출력 결과
		 * 
		 * 최대값 : 100
		 * 최소값 : 1
		 * 합계 :
		 * 평균 :
		 */
		
		// 배열 선언, 생성, 초기화
		int[] numbers = {3, 2, 14, 21, 100, 4, 2, 1};
		
		// 변수 선언 및 초기화
		int max = numbers[0];
		int min = numbers[0];
		int sum = 0;
		double avg = 0.0; 
		
		// 반복문(for)문을 통해 비교 및 대입
		for(int i = 0; i < numbers.length; i++) {
//			System.out.println(numbers[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);

 

 

 

 

< 배열 내의 데이터에 대한 연산 누적 >

0. 연산을 누적할 변수 선언 및 초기화
1. 배열 생성 및 데이터 저장
2. for문을 사용하여 배열 내의 모든 인덱스에 차례대로 접근
-> 배열의 인덱스 번호를 제어변수로 지정하여 해당 배열 내의 데이터를 누적 변수에 누적
3. for문 종료 후 누적 변수 값 사용

 

		// 0. 합계를 누적할 누적 변수(int형 변수 total) 선언 및 초기화
		int total = 0;
		
		// 1. 정수형 데이터 1~10까지를 저장하는 배열 arr 생성
		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 변수에 누적
			total += arr[i]; // 배열 arr의 i번 인덱스 데이터를 total에 누적

 

 

 

 

System.out.println(total);
		
		System.out.println("--------------------------");
		
		int oddTotal = 0; // 홀수의 합을 누적할 변수
		int evenTotal = 0; // 짝수의 합을 누적할 변수
		
		// 배열 내의 모든 인덱스에 차례대로 접근
		// -> 이때, 각 인덱스 데이터가 홀수, 짝수일 때 각각의 변수에 누적
		for(int i = 0 ; i < arr.length ; i++) {
			if(arr[i] % 2 == 0) { // 배열 데이터 arr[i]가 짝수일 때
				// 짝수 합을 저장하는 evenTotal에 배열 데이터를 누적
				evenTotal += arr[i];
			}else { // 배열 데이터 arr[i]가 홀수일 때
				// 홀수 합을 저장하는 oddTotal에 배열 데이터를 누적
				oddTotal += arr[i];
				
			}
		}
		
		System.out.println("배열 내의 홀수의 합: "+ oddTotal);
		System.out.println("배열 내의 짝수의 합: "+ evenTotal);

 

 

// 배열 내의 정수 중 최대값을 max에 저장 후 출력
		int max = 0;
		int[] array = {1, 5, 3, 8, 7};
		
		for(int i = 0; i < array.length; i++) {
//			System.out.println(array[i]);
			
			// max에 저장된 값과 배열(array)의 i번에 저장된 값을 비교하여
			// max값보다 배열 데이터(array[i]) 더 클 경우
			// 배열 데이터(array[i])를 max 변수에 저장
			if(array[i] > max) { // if(max <array[i]) {}
				System.out.println(array[i] + "가(이)"+max+"보다 크다!");
				max = array[i];
				System.out.println("----------> max = " + max);
			} else {
				System.out.println(array[i]+"가(이)"+max+"보다 크지 않다!");
			}
		}
		
		System.out.println("max =" +max);
		
		System.out.println("------------------------------");
		
		/*
		 * 주의! 최대값 등의 비교 시 비교 대상을 변수에 직접 저장할 경우
		 * 조건에 만족하지 않은 데이터가 있을 수 있다!
		 * 따라서, 배열 내의 데이터를 비교해야 하는 경우
		 * 비교 대상 값으로 배열 내의 데이터를 갖고 시작하는 것이 좋다!
		 * ex) 음수끼리의 최대값을 계산하는데 초기값으로 0을 설정하는 경우
		 *     모든 데이터가 0보다 크지 않으므로 최대값 계산이 불가능하게 됨
		 *     -> 따라서, 0 대신 배열의 첫 번째 데이터를 초기값으로 갖고 비교
		 */