Java - 배열,배열선언, 반복문을 활용한 배열

public class Ex {
 
    public static void main(String[] args) {
        /*
         * 배열(Array)
         * - 같은 타입의 여러개의 변수를 하나의 묶음으로 다루는 메모리 공간
         * 
         * [ 특징 ]
         * 1. 같은 타입의 값들만 저장 가능
         * 2. 기본 데이터타입과 참조 데이터타입 모두 배열로 저장 가능
         * 3. 여러 개의 변수에 해당하는 메모리 공간이 연속된 공간에 차례대로 생성됨 
         *    => 한 번 생성된 배열은 크기 변경 불가능
         * 4. 배열은 선언, 생성, 초기화 3단계의 과정을 거쳐서 사용
         * 5. 배열 생성 시 자동으로 기본값으로 초기화 됨
         *    (int형 기본값 : 0, double형 기본값 : 0.0, boolean형 기본값 : false 등)
         * 6. 배열 생성 시 인덱스 번호가 자동으로 부여되며, 0 ~ 배열크기-1 까지 사용됨
         * 7. 배열명(변수명)을 사용하여 배열을 관리 가능(인덱스 번호 지정 필요)
         * 8. 배열 크기는 배열명.length 속성을 사용하여 알아낼 수 있음
         * 
         * < 배열 선언 기본 문법 >
         * 데이터타입[] 변수명;
         * => 변수 선언 방법과 유사하나 데이터타입 뒤에 [] 기호를 붙여서 배열을 표시
         * => 배열 공간이 생성되기 전이므로, 아직 데이터 저장은 불가능
         * 
         * < 배열 생성 기본 문법 >
         * 변수명 = new 데이터타입[배열크기];
         * => new 키워드를 사용하여 배열 공간을 생성하는데
         *    데이터타입 뒤의 대괄호 안에 배열 크기 명시해야함
         * => 생성된 배열의 위치(주소값)를 선언된 배열 타입 변수에 저장
         * => 실제 메모리 공간이 생성되므로, 데이터 저장 가능함
         * => 생성된 배열에는 자동으로 인덱스 번호가 부여되며, 0부터 차례대로 인덱스가 부여됨
         *    (즉, 배열 인덱스는 0 ~ 배열크기-1 까지 자동으로 부여됨)
         *    
         * < 배열 선언 및 생성을 하나의 문장으로 결합한 문법 >
         * 데이터타입[] 변수명 = new 데이터타입[배열크기];
         * 
         * < 배열 접근 기본 문법 >
         * 변수명[인덱스번호] 형태로 배열 공간에 접근
         * => 지정된 배열의 인덱스에 접근하여 데이터 저장 또는 가져오기가 가능
         * 
         * < 배열의 모든 요소(인덱스)에 접근하는 반복문 공식 >
         * for(int i = 0; i < 배열명.length; i++) {
         *         // 배열 인덱스 접근
         * }
         */
        
        // 학생 점수 5개를 변수에 저장해야할 경우
        // => 각각의 변수를 별도로 선언하여 각 데이터를 저장해야함
        int score1 = 90, score2 = 60, score3 = 80, score4 = 100, score5 = 50;
        System.out.println(score1);
        System.out.println(score2);
        System.out.println(score3);
        System.out.println(score4);
        System.out.println(score5);
        
        System.out.println("--------------------");
        
        // 학생 점수 5개를 저장할 배열 선언 및 생성, 초기화
        // 1. 배열 선언
        int[] score; // int형 배열이 저장될 배열 변수 score 선언
        // => 아직 데이터 저장 공간은 생성되기 전이므로, 데이터 저장 불가
        
        // 2. 배열 생성
        score = new int[5]; // 5개의 int형 정수가 저장될 연속적인 공간이 생성되고 
        // 생성된 공간의 메모리 주소값이 변수 score 에 저장됨
        // => 이 때, 5개의 공간에는 각각의 인덱스번호가 자동으로 생성됨(0 ~ 4 까지)
        
        // 3. 배열 접근 및 초기화(기본값으로 자동으로 초기화 되어 있음)
//        System.out.println(score); // 배열명을 사용하여 그냥 출력할 경우 주소값 출력됨(데이터 X)
        System.out.println(score[0]); // 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(score[5]); // 오류 발생!
        // Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
        // at Ex6.main(Ex6.java:69)
        // => 배열 범위를 벗어난 인덱스 5 때문에 문제가 발생함. Ex6.java 파일의 69번 라인에 문제
        
        // 배열에 데이터 저장(초기화)
        score[0] = 90; // 배열의 0번 인덱스에 int형 데이터 90 저장
        score[1] = 60;
        score[2] = 100;
        score[3] = 80;
        score[4] = 70;
        
        // 반복문을 사용하여 배열의 모든 인덱스에 접근하는 방법
        // => 배열의 인덱스 번호 자리를 변수로 대체 가능하다!
//        for(int i = 0; i < 5; i++) {
//            System.out.println(i + "번 배열 인덱스 데이터 : " + score[i]);
//        }
        // => 배열의 모든 데이터 접근 시 조건식에 배열 크기를 직접 지정할 경우
        //    배열 크기가 변경되면 다시 코드를 수정하여 크기를 입력해야함
        
        // 배열명.length 속성을 사용하여 배열 크기를 알아낼 수 있으므로
        // 반복문 조건식에 배열명.length 속성을 활용하면 배열 크기가 변경되어도 동적으로 대처 가능
        System.out.println("배열 score 의 크기 : " + score.length);
        
        // 반복문 사용 기본 공식
        for(int i = 0; i < score.length; i++) { // 배열크기-1 까지 접근 가능
            System.out.println(i + "번 배열 인덱스 데이터 : " + score[i]);
        }
        
        System.out.println("======================");
        
        // int형 배열 arr 선언 및 5개 공간 생성
//        int[] arr;
//        arr = new int[5];
        
        // 위의 두 문장을 하나로 결합
        int[] arr = new int[5];
        
        /*
         * < 배열 생성과 동시에 리터럴을 지정하여 초기화를 수행하는 방법 >
         * 데이터타입[] 배열명 = {값1, 값2, ..., 값n};
         * => 값의 갯수에 따라 자동으로 배열을 생성하고 초기화 수행(0번 인덱스부터 차례대로 부여)
         * => 주의! 다음 문장 형태는 사용 불가!
         *    데이터타입[] 배열명 = new 데이터타입[배열크기]{값1, 값2, ..., 값n};
         * => 주의! 문장을 분리하여 사용할 경우 다음 문장 형태 사용 불가!
         *    데이터타입[] 배열명; // 배열 변수 선언을 먼저 한 뒤
         *    배열명 = {값1, 값2, ..., 값n}; // 초기화 문장을 따로 분리할 수 없음!
         * 
         * < 배열 생성 후 별도로 값을 한꺼번에 초기화를 수행하는 방법 >
         * 데이터타입[] 배열명;
         * 배열명 = new 데이터타입[]{값1, 값2, ..., 값n};
         * => 배열 변수를 별도로 선언한 후 배열 생성 코드를 사용하여 한꺼번에 초기화 가능
         *    단, 데이터타입 뒤에 [배열크기] 를 직접 명시하면 오류 발생하므로 배열크기 생략!
         *
         */
        
        // int형 배열 arr 을 선언하면서 정수 1,2,3,4,5 로 초기화
        int[] arr = {1, 2, 3, 4, 5}; // 5개짜리 int형 배열 공간 생성되면서 자동 초기화
        
        // 배열 arr 의 모든 요소 출력
        for(int i = 0; i < arr.length; i++) { 
            System.out.println(arr[i]);
        }
        
        // ------------------------------------------------
        // int형 배열 arr2 를 선언한 후, 별도로 정수 1, 2, 3, 4, 5 로 한꺼번에 초기화
        int[] arr2;
//        arr2 = {1, 2, 3, 4, 5}; // 오류 발생!
        arr2 = new int[]{1, 2, 3, 4, 5};
        
        for(int i = 0; i < arr2.length; i++) { 
            System.out.println(arr2[i]);
        }
        
        System.out.println("------------------");
        
        // String타입 배열 strs 에 문자열 "Hello", "World", "Java" 초기화
        String[] strs = {"Hello", "World", "Java"};
        
        for(int i = 0; i < strs.length; i++) { 
            System.out.println(strs[i]);
        }
        
        
        System.out.println("==========================================");
        
        // 배열 선언 시 [] 위치에 따른 차이점
        // 다음 두 문장은 모두 배열을 선언하는 문장
        int[] arr3; // 자바에서 사용하는 방법
        int arr4[]; // 자바 외의 다른 언어(주로 C)에서 사용하는 방법
        
        // 다음 두 문장은 배열 선언 결과가 다른 문장
        int[] arr5, arr6; // arr5, arr6 모두 배열 타입 변수
        int arr7, arr8[]; // arr7 은 기본형 int형 변수, arr8 은 배열 타입 변수
        
        System.out.println("==========================================");
        
        // 반복문을 사용하여 구구단의 결과값을 자동으로 배열에 저장
        int[] gugudan2 = new int[9];
        
        int dan = 2;
        
        for(int i = 0; i < gugudan2.length; i++) {
//            System.out.println(dan + " * " + (i + 1) + " = " + (dan * (i + 1)));
            // 배열의 각 인덱스에 구구단 결과값을 차례대로 저장
            // 0번 인덱스 : 2 * 1 = 2 결과 저장
            // 1번 인덱스 : 2 * 2 = 4 결과 저장
            // ...
            // 8번 인덱스 : 2 * 9 = 18 결과 저장
            gugudan2[i] = dan * (i + 1);
            System.out.println(gugudan2[i]);
        }
 
/*
         * 기본형 변수와 참조형 변수(배열)의 차이점
         * - 기본형(Primitive Type) 변수는 스택 공간의 변수에 데이터를 직접 저장
         * - 참조형(Reference Type) 변수는 스택 공간의 변수에 데이터를 직접 저장하지 않고,
         *   힙 공간에 생성된 실제 데이터가 저장된 공간의 주소값을 스택 공간의 변수에 저장한다.
         *   (ex. 배열, String 타입 문자열 등)
         *   => 저장된 주소값을 "참조"하여 실제 데이터에 접근하는 방식
         *   => 저장된 주소값이 없을 경우, 참조 값이 없다는 의미의 null 이라는 특수 데이터 사용
         *      (참조형 변수의 기본값이 null 이다!)
         * 
         */
        
        int num = 10; // 변수 a 는 기본형 변수로, 변수에 데이터가 직접 저장됨
        System.out.println(num); // 10 출력
        
        int[] arr = {10}; // 변수 arr 은 참조형 변수로, 데이터가 저장된 공간의 주소값이 저장됨
        System.out.println(arr); // [I@15db9742 출력(결과는 다름)
        // => 배열명만 지정하여 출력할 경우 배열이 생성된 곳(Heap 메모리)의 주소값이 출력됨
        // => 따라서, 배열명만 지정하지 않고, 반드시 배열명 뒤에 배열의 인덱스 지정 필수!
        
        System.out.println(arr[0]); // 배열 arr 이 가리키는 주소의 0번 인덱스 데이터 접근
        
        
        // String 타입 배열 공간에 데이터 초기화를 수행하지 않으면 기본값인 null 로 초기화됨
        String[] str = new String[3];
        System.out.println(str[0]); // null 값 출력됨
        
        System.out.println("==============================");
        
        int[] a = {1, 2, 3};
        int[] b = {4, 5, 6};
        int[] c = {7, 8, 9};
        
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
        
        b = a; // 참조형 변수 a 의 주소값을 참조형 변수 b 에 전달(복사)
        // => 기존에 b가 가리키던 4, 5, 6 이 저장된 배열 공간은
        //    더 이상 참조되지 않으므로, 가비지 컬렉터(GC)에 의해 제거됨(메모리 공간 자동 확보됨)
        for(int i = 0; i < a.length; i++) {
            System.out.println("a = " + a[i] + ", b = " + b[i] + ", c = " + c[i]);
        }
        
        System.out.println("--------------");
        
        a = c; // 참조형 변수 c 의 주소값을 참조형 변수 a 에 전달(복사)
        // => a가 1, 2, 3 을 가리키고 있다가, c 가 가리키는 7, 8, 9 공간을 가리키고
        //    b는 여전히 1, 2, 3 을 가리키고 있으므로 1, 2, 3 공간은 제거 대상이 아니다!
        for(int i = 0; i < a.length; i++) {
            System.out.println("a = " + a[i] + ", b = " + b[i] + ", c = " + c[i]);
        }
 
/*
         * 2차원 배열
         * - 1차원 배열이 여러개의 묶음으로 관리되는 배열
         * - 행과 열로 이루어진 테이블 구조와 유사함
         *   => 행, 열의 인덱스는 1차원 배열과 동일(0번부터 시작)
         * - 2차원 배열에서 행 크기는 배열명.length 를 사용하여 알아낼 수 있으며,
         *   열 크기는 배열명[행번호].length 를 사용하여 각 열의 크기를 알아낼 수 있다.
         * 
         * < 2차원 배열 선언 및 생성 기본 문법 >
         * 데이터타입[][] 배열명 = new 데이터타입[행크기][열크기];
         * 
         * < 2차원 배열 접근 기본 문법 >
         * 배열명[행번호][열번호]
         * 
         * < 2차원 배열 선언, 생성, 초기화를 한꺼번에 수행하는 문법 >
         * 데이터타입[][] 배열명 = {
         *         {값1, 값2, ..., 값n}, // 0행(0열 데이터, 1열 데이터, ..., n열 데이터)
         *         {값1, 값2, ..., 값n}, // 1행(0열 데이터, 1열 데이터, ..., n열 데이터)
         *           ..생략..
         *         {값1, 값2, ..., 값n}  // n행(0열 데이터, 1열 데이터, ..., n열 데이터)
         * };
         * 
         */
        
        /*
         * int형 2차원 배열 arr 생성하고 다음과 같은 형태로 데이터 저장
         *  1(0,0)  2(0,1)  3(0,2)
         *  4(1,0)  5(1,1)  6(1,2)
         * => 2행 3열의 배열 필요
         */
        int[][] arr = new int[2][3]; // 2행 3열 구조의 배열 생성
        // => 배열 변수 arr 에는 2행에 대한 주소값이 저장됨
        //    따라서, 배열 변수 arr을 따라가면 행에 해당하는 공간 생성되어 있음
        // => 배열 변수 arr 의 각 행에는 각 열에 대한 주소값이 저장됨
        //    따라서, 배열변수명[행번호] 를 따라가면 열에 해당하는 공간 생성되어 있음
        //    열 공간에는 실제 데이터가 저장됨
        
//        arr[0][0] = 1;
//        arr[0][1] = 2;
//        arr[0][2] = 3;
//        arr[1][0] = 4;
//        arr[1][1] = 5;
//        arr[1][2] = 6;
        
        arr[0][0] = 1; arr[0][1] = 2; arr[0][2] = 3;
        arr[1][0] = 4; arr[1][1] = 5; arr[1][2] = 6;
        
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);
        
        // 배열 크기 알아내기
        // 1. 배열의 행 크기 알아내기 = 배열명.length 사용
        System.out.println("배열 arr 의 행 크기 : " + arr.length);
        
        // 2. 배열의 각 행에 대한 열의 크기 알아내기 : 배열명[행번호].length 사용
        System.out.println("배열 arr 의 0번 행의 열 크기 : " + arr[0].length);
        System.out.println("배열 arr 의 1번 행의 열 크기 : " + arr[1].length);
        
        System.out.println("-----------------------------------");
        
        // 반복문을 사용하여 2차원 배열의 모든 요소에 접근하기
        for(int i = 0; i < 2; i++) { // 바깥쪽 for문 = 행 반복
            
            for(int j = 0; j < 3; j++) { // 안쪽 for문 = 열 반복
//                System.out.println(i + ", " + j);
                // i 와 j 를 사용하여 2차원 배열 행, 열에 해당하는 인덱스 지정
                System.out.println(arr[i][j]);
            }
            
        }
        
        // ------------ 위의 중첩 for문을 사용하여 2차원 배열 접근하는 다른 방법 ------------
        // => length 속성 활용하는 공식!
        // => 행크기는 배열명.length, 열크기는 배열명[행번호].length 를 활용하여 반복 수행
        for(int i = 0; i < arr.length; i++) { // 바깥쪽 for문 = 행 반복
            
            for(int j = 0; j < arr[i].length; j++) { // 안쪽 for문 = 열 반복
                System.out.println(arr[i][j]);
            }
            
        }
        
        System.out.println("===================================");
        
        // 2차원 배열 선언, 생성 및 초기화를 한꺼번에 수행
        int[][] arr2 = {
                {1, 2}, // 0번 행(0열 데이터, 1열 데이터)
                {3, 4}, // 1번 행(0열 데이터, 1열 데이터)
                {5, 6}  // 2번 행(0열 데이터, 1열 데이터)
        };
        
        for(int i = 0; i < arr2.length; i++) {
            for(int j = 0; j < arr2[i].length; j++) {
                System.out.println(arr2[i][j]);
            }
                
        }
        
        System.out.println("==================================");
        
        /*
         * 학생 점수를 2차원 배열(score)에 다음과 같이 저장 후 출력
         *         국어  영어  수학  
         * 홍길동   80    70    80   
         * 이순신   90    90    90
         * 강감찬   50    60    77
         * 김태희  100   100   100
         * 전지현   80    80    60
         * -------------------------
         * < 학생별 총점 >
         * 홍길동 : 230점    
         * 이순신 : 270점
         * 강감찬 : 187점
         * 김태희 : 300점
         * 전지현 : 220점
         * -------------------------
         * < 과목별 평균 >
         * 
         */
            
        // 학생 5명의 국어, 영어, 수학 점수 저장하는 2차원 배열 생성
        int[][] score = {
                {80, 70, 80},
                {90, 90, 90},
                {50, 60, 77},
                {100, 100, 100},
                {80, 80, 60}
        };
        
        // 학생별 총점을 저장하는 1차원 배열(studentTotal) 생성
        int[] studentTotal = new int[5]; // 자동으로 0으로 초기화 됨
        /*
         * 홍길동   80(0,0)  70(0,1)  80(0,2) => studentTotal[0] 배열에 누적
         * 이순신   90(1,0)  90(1,1)  90(1,2) => studentTotal[1] 배열에 누적
         * 강감찬   50(2,0)  60(2,1)  77(2,2) => studentTotal[2] 배열에 누적
         * 김태희  100(3,0) 100(3,1) 100(3,2) => studentTotal[3] 배열에 누적
         * 전지현   80(4,0)  80(4,1)  60(4,2) => studentTotal[4] 배열에 누적
         */
//        studentTotal[0] += score[0][0];
//        studentTotal[0] += score[0][1];
//        studentTotal[0] += score[0][2];
//        studentTotal[1] += score[1][0];
//        studentTotal[1] += score[1][1];
//        studentTotal[1] += score[1][2];
//        studentTotal[2] += score[2][0];
//        studentTotal[2] += score[2][1];
//        studentTotal[2] += score[2][2];
//        studentTotal[3] += score[3][0];
//        studentTotal[3] += score[3][1];
//        studentTotal[3] += score[3][1];
//        studentTotal[4] += score[4][0];
//        studentTotal[4] += score[4][1];
//        studentTotal[4] += score[4][2];
        
        // 과목별 평균 계산을 위해 과목별 총점 누적
        int[] subjectTotal = new int[3]; // 0번 : 국어, 1번 : 영어, 2번 : 수학
        /*
         *                국어           영어           수학
         * 홍길동        80(0,0)        70(0,1)        80(0,2)
         * 이순신        90(1,0)        90(1,1)        90(1,2)
         * 강감찬        50(2,0)        60(2,1)        77(2,2)
         * 김태희       100(3,0)       100(3,1)       100(3,2)
         * 전지현        80(4,0)        80(4,1)        60(4,2)
         * -------------------------------------------------------
         *          subjectTotal[0] subjectTotal[1] subjectTotal[2]
         */
        
        for(int i = 0; i < score.length; i++) { // 바깥쪽 for문(행반복)
            
            for(int j = 0; j < score[i].length; j++) { // 안쪽 for문(열반복)
                System.out.print(score[i][j] + "  ");
                
                // 각 학생별 점수를 studentTotal 배열에 누적
                // => 학생 점수의 행번호(i)와 학생별 총점의 인덱스가 동일함
                studentTotal[i] += score[i][j]; // 제어변수 i값을 총점 배열 인덱스로 활용
                
                // 각 과목별 총점을 subjectTotal 배열에 누적
                subjectTotal[j] += score[i][j];
            }
            
            System.out.println(); // 줄바꿈
            
        }
            
        System.out.println("--------------------");
        
        System.out.println("< 학생별 총점 >");
        System.out.println("홍길동 : " + studentTotal[0] + "점");
        System.out.println("이순신 : " + studentTotal[1] + "점");
        System.out.println("강감찬 : " + studentTotal[2] + "점");
        System.out.println("김태희 : " + studentTotal[3] + "점");
        System.out.println("전지현 : " + studentTotal[4] + "점");
        System.out.println("--------------------");
        
        System.out.println("< 과목별 평균 >");
        System.out.println("국어 : " + (subjectTotal[0] / (double)studentTotal.length) + "점");
        System.out.println("영어 : " + (subjectTotal[1] / (double)studentTotal.length) + "점");
        System.out.println("수학 : " + (subjectTotal[2] / (double)studentTotal.length) + "점");
 
        
/*
         * 1. 정수형 배열 arr 에 1 ~ 10 까지 차례대로 저장 후 출력
         * 2. 정수형 변수 total 에 배열 내의 모든 데이터 합 계산하여 저장(= 합계 누적) 후 출력
         * 3. 정수형 변수 evenTotal 에 배열 내의 데이터 짝수 합 계산하여 저장
         *    정수형 변수 oddTotal 에 배열 내의 데이터 홀수 합 계산하여 저장
         * 
         */
        
        int total = 0, evenTotal = 0, oddTotal = 0;
        
        // 1. 정수형 배열 arr 에 1 ~ 10 까지 차례대로 저장 후 출력
//        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//        for(int i = 0; i < arr.length; i++) {
//            System.out.println(arr[i]);
//        }
        
        // 1-2. 다른 방법
        int[] arr = new int[10];
        for(int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
            System.out.println(arr[i]);
        }
        
        System.out.println("-----------------------");
        // 2. 정수형 변수 total 에 배열 내의 모든 데이터 합 계산하여 저장(= 합계 누적) 후 출력
        for(int i = 0; i < arr.length; i++) {
            total += arr[i]; // 배열의 i번 인덱스 데이터를 total 에 누적
        }
        
        System.out.println(total);
        
        System.out.println("-----------------------");
        // 3. 정수형 변수 evenTotal 에 배열 내의 데이터 짝수 합 계산하여 저장
        //    정수형 변수 oddTotal 에 배열 내의 데이터 홀수 합 계산하여 저장
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] % 2 == 0) { // 짝수
                evenTotal += arr[i]; // 짝수 합 누적
            } else { // 홀수
                oddTotal += arr[i]; // 홀수 합 누적
            }
        }
        
        System.out.println("짝수 합 : " + evenTotal);
        System.out.println("홀수 합 : " + oddTotal);
        
    }
 
}

배열에 대해서 배우는 시간을 가져보았는데 처음엔 좀 생소하게 느껴졌지만 개념 자체는 어려운 게 없어서 금방 이해가 되었다. 배열 선언 부분이 새로운 느낌이라 첨엔 낯설었는데 생각보다 쉽게 다가와서 금방 이해가 되었고 반복문을 활용하여 배열에 순서대로 값을 초기화하는 부분도 배웠다. 조금 복잡해 보이지만 원리 자체는 너무 간단해서 금방 배울 수 있었다. 그리고 배열의 길이를 나타내는. length를 배우게 되었다. 앞으로 자주 사용하게 될 거라고 하셨는데 잘 외워 둬야겠다. 그리고 2차원 배열에 대해서도 배우게 되었는데 앞서 배웠던 1차원 배열의 확장 느낌이라 어려운 건 없었다. 학생들의 총점과 평균점수, 과목별 총점수에서 과목별 평균을 배열과 배열. length를 활용하여 풀어보았는데 좀 복잡했지만 이해는 되었다. 그래도 복잡하다고 느꼈던 만큼 좀 더 신경 써서 복습을 해야 할 것 같다.