[JAVA] 자바의 배열 Array

배열(Array)

1. 같은 타입의 여러 데이터를 하나의 묶음으로 다루는 것
2. 동일한 데이터타입 변수들의 집합
3. 배열은 메모리 상의 연속된 공간에 생성됨
4. 따라서, 한 번 생성한 배열의 크기를 변경할 수 없다
5. 기본 데이터타입과 참조 데이터타입 모두를 배열로 생성 가능
6. 저장된 데이터들은 **배열명(변수명)**을 사용하여 관리
7. 배열의 크기는 배열명.length 속성을 사용하여 알아낼 수 있다
8. 배열 생성 시 각 데이터 저장공간에는 **인덱스(첨자)**라는 번호가 붙는다
9. 따라서, 배열의 인덱스 범위는 0 ~ 배열크기-1 까지 자동 부여됨
10. 배열을 사용하려면 배열 선언 -> 생성 -> 초기화 단계를 거쳐야한다.기본값 : byte&short&int = 0, long = 0L, float = 0.0f, double = 0.0 boolean = false, char = '\u0000' 또는 0 참조형(String 등)의 기본값은 무조건 null
11. 단, 배열을 생성하면 기본값으로 자동으로 초기화 일어남

 

배열 선언 기본 문법

데이터타입[] 변수명;

단, 배열 선언만 했을 경우 데이터 저장 불가 (메모리에 실제 배열 공간이 생성되기 전이므로)

배열이 생성된 주소값을 저장하는 변수 선언

 

배열 생성 기본 문법

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

**메모리(Heap)**에 실제 데이터 저장이 가능하도록 공간을 할당받음

 

배열 접근 기본 문법

변수명[인덱스]

 

배열 초기화 기본 문법

변수명[인덱스] = 데이터;

 

배열 선언 및 생성을 동시에 수행하는 문법

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

 

배열 선언, 생성, 초기화를 동시에 수행하는 문법

데이터타입[] 변수명 = {데이터1, 데이터2, ..., 데이터n};

배열 크기를 지정하지 않아도 데이터 갯수만큼의 배열이 자동으로 생성됨 (단, 배열 내의 데이터가 모두 준비된 경우에만 가능한 문법)

 

배열 크기 조회

배열명.length 속성 사용하여 크기 전달받을 수 있음

출력문에 배열명.length 전달 또는 변수에 배열명.length 저장

 

		// 학생 5명의 점수를 저장하는 변수 사용 시
		int score1 = 80, score2 = 60, score3 = 70, score4 = 100, score5 = 10;
		System.out.println("1번 학생 점수 : " + score1);
		System.out.println("2번 학생 점수 : " + score2);
		System.out.println("3번 학생 점수 : " + score3);
		System.out.println("4번 학생 점수 : " + score4);
		System.out.println("5번 학생 점수 : " + score5);
		
		int sum = 0;
		sum += score1;
		sum += score2;
		// ... 생략 ...
		// => 대량의 데이터를 일반 변수로 관리하기엔 부적합하다!
		//    따라서, 배열을 통해 여러개의 데이터를 하나의 묶음으로 관리!

		// int형 정수를 저장하는 변수 num 을 선언
		//		int num;
		// int형 변수 num 에 정수 10을 저장
		//		num = 10;
		//		num = 20; // 만약, 20을 저장하게 되면 기존의 정수 10은 제거됨
		// int형 변수 num 에 저장된 값을 출력
		//		System.out.println(num);
		
		// int형 정수 3개를 저장하기 위한 배열 변수 arr 을 선언
		// 배열 선언 : 데이터타입[] 배열명;
		//		int[] arr; // int형 정수 저장을 위한 배열 공간의 이름을 arr 로 선언
		// => 주의! 아직 정수를 저장할 수 있는 메모리 공간 생성 전이므로
		//    배열에 데이터 저장은 불가능하다!
		
		// 배열 생성 : 배열명 = new 데이터타입[배열크기];
		//		arr = new int[3];
		// => 실제 데이터 저장이 가능한 메모리 공간 3개가 연속적으로 생성됨
		// => 이 때, 배열이 생성되면 자동으로 배열 내부 공간의 데이터가 
		//    기본값으로 초기화 됨
		
		// 위의 배열 선언 및 배열 생성 코드를 한 문장으로 결합
		int[] arr = new int[3]; // 0 ~ 2번 인덱스를 갖는 배열 공간 생성됨
		
		// 배열의 각 인덱스에 접근하여 저장된 데이터 출력
		System.out.println("배열 arr 의 0번 인덱스 : " + arr[0]);
		System.out.println("배열 arr 의 1번 인덱스 : " + arr[1]);
		System.out.println("배열 arr 의 2번 인덱스 : " + arr[2]);
		//		System.out.println("배열 arr 의 3번 인덱스 : " + arr[3]); // 오류
		// => 0 ~ 2번까지의 인덱스만 존재하므로, 존재하지 않는 인덱스를
		//    접근하려 할 경우 ArrayIndexOutOfBoundsException 예외 발생
		// => java.lang.ArrayIndexOutOfBoundsException: 3
		//    at Ex.main(Ex.java:92)
		//    => 3이라는 인덱스가 잘못됐다는 메세지이며, 92번 라인이 원인.
		
		// 배열 arr 의 0번 인덱스에 정수 10을 저장
		arr[0] = 10;
		// 1번 인덱스에 20, 2번 인덱스에 30 저장 후 출력
		arr[1] = 20;
		arr[2] = 30;
		
		System.out.println("배열 arr 의 0번 인덱스 : " + arr[0]);
		System.out.println("배열 arr 의 1번 인덱스 : " + arr[1]);
		System.out.println("배열 arr 의 2번 인덱스 : " + arr[2]);
		
		arr[2] = 100;
		System.out.println("배열 arr 의 2번 인덱스 : " + arr[2]);
		
		System.out.println("-----------------------------------");
		
		// 배열 선언, 생성, 초기화를 한꺼번에 수행 
		// = 리터럴을 사용하여 배열을 직접 생성하는 문법 사용
		// 데이터타입[] 배열명 = {값1, 값2, ..., 값n};
		// => n개 만큼의 배열이 자동으로 생성되며 0 ~ n-1 까지 인덱스 부여
		// 1) int형 배열 5개 생성하면서 1, 2, 3, 4, 5 로 초기화
		int[] nums = {1, 2, 3, 4, 5}; // 0 ~ 4번 인덱스까지 자동 부여됨
		System.out.println("배열 nums 의 0번 인덱스 : " + nums[0]);
		System.out.println("배열 nums 의 1번 인덱스 : " + nums[1]);
		System.out.println("배열 nums 의 2번 인덱스 : " + nums[2]);
		System.out.println("배열 nums 의 3번 인덱스 : " + nums[3]);
		System.out.println("배열 nums 의 4번 인덱스 : " + nums[4]);
		
		
		// 학생 3명의 이름을 배열로 갖는 names 배열 생성
		// => "홍길동", "이순신", "강감찬" 으로 초기화
		String[] names = {"홍길동", "이순신", "강감찬"};
		System.out.println("배열 names 의 0번 인덱스 : " + names[0]);
		System.out.println("배열 names 의 1번 인덱스 : " + names[1]);
		System.out.println("배열 names 의 2번 인덱스 : " + names[2]);
		
		System.out.println("=======================================");
		
		// 각 배열의 크기 : 배열명.length 속성 사용
		System.out.println("배열 names 의 크기(길이) : " + names.length);
		System.out.println("배열 nums 의 크기(길이) : " + nums.length);
		
		System.out.println("=======================================");

		// 변수를 인덱스 번호로 활용하여 배열 내의 모든 데이터에 접근하는 방법 
		int index = 0;
		System.out.println("배열 names 의 0번 인덱스 : " + names[index]);
		index++;
		System.out.println("배열 names 의 1번 인덱스 : " + names[index]);
		index++;
		System.out.println("배열 names 의 2번 인덱스 : " + names[index]);
		
		// 반복문을 사용하여 배열 내의 모든 데이터에 접근
		// 1) names 배열의 모든 이름 출력
		for(int i = 0; i < 3; i++) {
		//			System.out.println(names[i]);
			System.out.printf(
					"배열 names 의 %d번 인덱스 : %s\n", i, names[i]);
		}
		
		// 2) nums 배열의 모든 정수 출력
		for(int i = 0; i < 5; i++) {
			System.out.printf(
					"배열 nums 의 %d번 인덱스 : %d\n", i, nums[i]);
		}
		
		System.out.println("=========================");
		
		// 반복문을 사용하여 배열 내의 모든 데이터에 접근
		// => 단, 조건식에 배열 크기를 직접 지정하지 않고
		//    배열명.length 속성을 사용하여 동적으로 변경될 수 있도록 지정
		// 1) names 배열의 모든 이름 출력
		for(int i = 0; i < names.length; i++) {
		//					System.out.println(names[i]);
			System.out.printf(
					"배열 names 의 %d번 인덱스 : %s\n", i, names[i]);
		}
		
		// 2) nums 배열의 모든 정수 출력
		for(int i = 0; i < nums.length; i++) {
			System.out.printf(
					"배열 nums 의 %d번 인덱스 : %d\n", i, nums[i]);
		}

 

반응형

 

 

다차원 배열

• 1차원 배열을 여러겹 중첩시킨 형태의 배열 (일반적인 다차원 배열은 2차원까지만 사용)
• 2차원 배열은 행열의 형태를 지님
• 2차원 배열의 행크기 : 배열명.length
• 2차원 배열 특정 행의 열크기 : 배열명[행번호].length

 

2차원 배열 생성 기본 문법

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

 

2차원 배열 접근 기본 문법

변수명[행인덱스][열인덱스]

 

2차원 배열 생성 및 초기화 동시에 수행하는 문법

데이터타입[][] 변수명 = {
 		{값1, 값2, ..., 값n}, // 0번 행(0열, 1열, ..., n열)
 		{값1, 값2, ..., 값n}, // 1번 행(0열, 1열, ..., n열)
 		... 생략 ...
 		{값1, 값2, ..., 값n}  // x번 행(0열, 1열, ..., n열)
 };

		// 2차원 배열 변수 score 선언
		//		int[][] score;
		
		// 2차원 배열 5행 3열 크기를 갖는 int형 배열 생성
		//		score = new int[5][3];
		
		// 위의 두 문장을 하나로 결합하여 배열 선언 및 생성을 동시에 수행
		int[][] score = new int[5][3];
		
		/*
		 * 다음과 같은 데이터로 초기화
		 * -----------------------------
		 *   국어      영어      수학
		 *  80(0,0)   80(0,1)   80(0,2)
		 *  90(1,0)   90(1,1)   90(1,2)
		 * 100(2,0)   80(2,1)   60(2,2)
		 * 100(3,0)  100(3,1)  100(3,2)
		 *  77(4,0)   80(4,1)   90(4,2)
		 * -----------------------------
		 */
		score[0][0] = 80; score[0][1] = 80; score[0][2] = 80;
		score[1][0] = 90; score[1][1] = 90; score[1][2] = 90;
		score[2][0] = 100; score[2][1] = 80; score[2][2] = 60;
		score[3][0] = 100; score[3][1] = 100; score[3][2] = 100;
		score[4][0] = 77; score[4][1] = 80; score[4][2] = 90;
		
		System.out.printf("1번 학생 : %3d %3d %3d\n", 
								score[0][0], score[0][1], score[0][2]);
		System.out.printf("2번 학생 : %3d %3d %3d\n", 
								score[1][0], score[1][1], score[1][2]);
		System.out.printf("3번 학생 : %3d %3d %3d\n", 
								score[2][0], score[2][1], score[2][2]);
		System.out.printf("4번 학생 : %3d %3d %3d\n", 
								score[3][0], score[3][1], score[3][2]);
		System.out.printf("5번 학생 : %3d %3d %3d\n", 
								score[4][0], score[4][1], score[4][2]);
		
		// 행번호(i) 0 ~ 4 까지 반복
		for(int i = 0; i < 5; i++) {
		//			System.out.println("i = " + i);
			System.out.print((i + 1) + "번 학생 : ");
			
			// 열번호(j) 0 ~ 2 까지 반복
			for(int j = 0; j < 3; j++) {
		//				System.out.println("------------------ j = " + j);
				// 2차원 배열 score 의 행, 열에 대한 중첩 for문
				System.out.printf("%3d ", score[i][j]);
			}
			
			System.out.println(); // 줄바꿈
			
		}

		// 2차원 배열의 행크기 : 배열명.length
		// 2차원 배열 특정 행의 열크기 : 배열명[행번호].length
		System.out.println("2차원 배열 score 의 행크기 : " + score.length);
		System.out.println("score 1번행 열크기 : " + score[1].length);
		System.out.println("score 2번행 열크기 : " + score[2].length);
		
		// 2차원 배열의 모든 데이터를 출력하는 공식
		// => 바깥쪽 for문은 행 반복하는 반복문(배열명.length)
		// => 안쪽 for문은 행의 열을 반복하는 반복문(배열명[행번호].length)
		for(int i = 0; i < score.length; i++) { // 행반복(0 ~ 4)
			System.out.print((i + 1) + "번 학생 : ");
			
			for(int j = 0; j < score[i].length; j++) { // 열반복(0 ~ 3)
				System.out.printf("%3d ", score[i][j]);
			}
			
			System.out.println();
			
		}
		
		System.out.println("============================");
		
		/*
		 * 2차원 배열의 생성 및 초기화를 한꺼번에 수행
		 * 다음과 같은 데이터로 초기화
		 * -----------------------------
		 *   국어      영어      수학
		 *  80(0,0)   80(0,1)   80(0,2)
		 *  90(1,0)   90(1,1)   90(1,2)
		 * 100(2,0)   80(2,1)   60(2,2)
		 * 100(3,0)  100(3,1)  100(3,2)
		 *  77(4,0)   80(4,1)   90(4,2)
		 * -----------------------------
		 */
		int[][] score2 = {
				{80, 80, 80},    // 0행(0열, 1열, 2열)
				{90, 90, 90},    // 1행(0열, 1열, 2열)
				{100, 80, 60},   // 2행(0열, 1열, 2열)
				{100, 100, 100}, // 3행(0열, 1열, 2열)
				{77, 80, 90}     // 4행(0열, 1열, 2열)
		};
		
		for(int i = 0; i < score2.length; i++) {
			for(int j = 0; j < score2[i].length; j++) {
				System.out.print(score2[i][j] + " ");
			}
			System.out.println();
		}

향상된 for문(ForEach 문)

• 배열 등의 객체 반복을 위해 for문 사용 시 조건식, 증감식 등이 없는 단순한 for문
• 지정된 배열 내의 모든 데이터를 하나씩 꺼내서 좌변에 선언된 변수에 저장 반복하고 자동 종료
• 단, 특정 범위만 반복할 수 없고, 인덱스 사용 불가

기본 문법

for(변수선언 : 배열) {
 		// 배열 내의 데이터를 하나 꺼내서 좌변의 변수에 저장하고
		// 블록 내에서 해당 변수를 사용하여 데이터 접근 가능
 }

int[] arr = {1, 2, 3, 4, 5, 6};
		
		// 기존의 for문 사용 시
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		System.out.println("-----------------");
		
		// 향상된 for문 사용 시
		for(int num : arr) {
			// 배열 arr 내의 데이터를 차례대로 꺼내서 num 에 저장 반복
			System.out.println(num);
		}
		
		System.out.println("=====================");
		
		int[][] score = {
				{80, 80, 80},    // 0행(0열, 1열, 2열)
				{90, 90, 90},    // 1행(0열, 1열, 2열)
				{100, 80, 60},   // 2행(0열, 1열, 2열)
				{100, 100, 100}, // 3행(0열, 1열, 2열)
				{77, 80, 90}     // 4행(0열, 1열, 2열)
		};
		
		for(int[] arr2 : score) {
			for(int num : arr2) {
				System.out.println(num);
			}
		}