본문 바로가기
  • 코딩, 허쌤이 떠먹여 줄게
BackEnd/Java

5_1 . 이차원 배열 연습문제

by 허쌤 2026. 1. 6.

📘 이차원 배열 연습문제

목차

  1. 문제 1: 이차원 배열 출력하기
  2. 문제 2: 모든 요소의 합 구하기
  3. 문제 3: 행별 합 구하기
  4. 문제 4: 최대값 찾기
  5. 문제 5: 3×3 배열에 1~9 저장하기
  6. 핵심 정리

✅ 문제 1: 이차원 배열 출력하기 (기본)

문제

다음 이차원 배열을 행과 열 형태로 출력하세요.

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6}
};

출력 결과

1 2 3
4 5 6

정답 코드

public class Ex1 {
    public static void main(String[] args) {
        int[][] arr = {
            {1, 2, 3},
            {4, 5, 6}
        };

        for (int i = 0; i < arr.length; i++) {      // 행
            for (int j = 0; j < arr[i].length; j++) { // 열
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

풀이 설명

  1. 이중 for문 사용

    • 바깥쪽 반복문 (i): 행을 순회 (0번째 행, 1번째 행)
    • 안쪽 반복문 (j): 각 행의 열을 순회 (0번째 열, 1번째 열, 2번째 열)
  2. 핵심 개념

    • arr.length → 행의 개수 (2개)
    • arr[i].length → 각 행의 열 개수 (각각 3개)
    • arr[i][j] → i번째 행, j번째 열의 값
  3. 출력 방법

    • System.out.print(): 줄바꿈 없이 출력 (공백 포함)
    • System.out.println(): 각 행 출력 후 줄바꿈
  4. 실행 과정

    i=0일 때:
      j=0: arr[0][0] = 1 출력
      j=1: arr[0][1] = 2 출력
      j=2: arr[0][2] = 3 출력
      줄바꿈
    
    i=1일 때:
      j=0: arr[1][0] = 4 출력
      j=1: arr[1][1] = 5 출력
      j=2: arr[1][2] = 6 출력
      줄바꿈

✅ 문제 2: 모든 요소의 합 구하기

문제

아래 이차원 배열의 모든 값의 합을 구하여 출력하세요.

int[][] arr = {
    {10, 20},
    {30, 40},
    {50, 60}
};

출력 예

합: 210

정답 코드

public class Ex2 {
    public static void main(String[] args) {
        int[][] arr = {
            {10, 20},
            {30, 40},
            {50, 60}
        };

        int sum = 0;  // 합을 저장할 변수

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];  // 누적 합
            }
        }

        System.out.println("합: " + sum);
    }
}

풀이 설명

  1. 누적 변수 초기화

    • int sum = 0; → 모든 값을 더할 변수 생성
  2. 이중 반복문으로 모든 요소 접근

    • 각 요소 arr[i][j]를 순회하면서 sum에 누적
    • sum += arr[i][j];sum = sum + arr[i][j];와 동일
  3. 계산 과정

    초기값: sum = 0
    
    arr[0][0] = 10  → sum = 0 + 10 = 10
    arr[0][1] = 20  → sum = 10 + 20 = 30
    arr[1][0] = 30  → sum = 30 + 30 = 60
    arr[1][1] = 40  → sum = 60 + 40 = 100
    arr[2][0] = 50  → sum = 100 + 50 = 150
    arr[2][1] = 60  → sum = 150 + 60 = 210
  4. 핵심 포인트

    • sum 변수는 반복문 밖에서 초기화 (모든 값의 합을 구해야 하므로)
    • 모든 요소를 다 더해야 하므로 조건 없이 누적

✅ 문제 3: 행별 합 구하기 ⭐

문제

다음 배열에서 각 행의 합을 각각 출력하세요.

int[][] scores = {
    {90, 80, 70},
    {85, 95, 88}
};

출력 예

1행 합: 240
2행 합: 268

정답 코드

public class Ex3 {
    public static void main(String[] args) {
        int[][] scores = {
            {90, 80, 70},
            {85, 95, 88}
        };

        for (int i = 0; i < scores.length; i++) {
            int sum = 0;   // ★ 행마다 초기화
            for (int j = 0; j < scores[i].length; j++) {
                sum += scores[i][j];
            }
            System.out.println((i + 1) + "행 합: " + sum);
        }
    }
}

풀이 설명

  1. 핵심 차이점

    • 문제 2와 달리 sum 변수를 행마다 0으로 초기화
    • 각 행의 합을 별도로 계산해야 함
  2. 변수 위치의 중요성

    // ❌ 잘못된 방법 (문제 2처럼)
    int sum = 0;  // 반복문 밖에 선언
    for (int i = 0; i < scores.length; i++) {
        for (int j = 0; j < scores[i].length; j++) {
            sum += scores[i][j];  // 모든 행의 합이 누적됨
        }
        System.out.println((i + 1) + "행 합: " + sum);
    }
    // 결과: 1행 합: 240, 2행 합: 508 (잘못됨!)
    
    // ✅ 올바른 방법
    for (int i = 0; i < scores.length; i++) {
        int sum = 0;  // 각 행마다 새로운 sum
        for (int j = 0; j < scores[i].length; j++) {
            sum += scores[i][j];
        }
        System.out.println((i + 1) + "행 합: " + sum);
    }
  3. 실행 과정

    i=0 (첫 번째 행):
      sum = 0 (초기화)
      sum += 90  → sum = 90
      sum += 80  → sum = 170
      sum += 70  → sum = 240
      출력: "1행 합: 240"
    
    i=1 (두 번째 행):
      sum = 0 (다시 초기화!) ⭐
      sum += 85  → sum = 85
      sum += 95  → sum = 180
      sum += 88  → sum = 268
      출력: "2행 합: 268"
  4. 핵심 포인트

    • 행별 합을 구하려면 → sum안쪽 반복문 시작 전에 초기화
    • 전체 합을 구하려면 → sum바깥쪽 반복문 시작 전에 초기화

✅ 문제 4: 최대값 찾기

문제

아래 이차원 배열에서 가장 큰 값을 찾아 출력하세요.

int[][] arr = {
    {3, 7, 2},
    {9, 4, 1}
};

출력 예

최대값: 9

정답 코드

public class Ex4 {
    public static void main(String[] args) {
        int[][] arr = {
            {3, 7, 2},
            {9, 4, 1}
        };

        int max = arr[0][0];  // 첫 값으로 초기화

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] > max) {
                    max = arr[i][j];
                }
            }
        }

        System.out.println("최대값: " + max);
    }
}

풀이 설명

  1. 최대값 변수 초기화

    • int max = arr[0][0]; → 첫 번째 요소로 초기화
    • 배열의 모든 값이 음수일 수도 있으므로, 0으로 초기화하면 안 됨
  2. 비교 로직

    if (arr[i][j] > max) {
        max = arr[i][j];  // 더 큰 값으로 업데이트
    }
  3. 실행 과정

    초기값: max = arr[0][0] = 3
    
    arr[0][0] = 3  → 3 > 3? false → max = 3 유지
    arr[0][1] = 7  → 7 > 3? true  → max = 7
    arr[0][2] = 2  → 2 > 7? false → max = 7 유지
    arr[1][0] = 9  → 9 > 7? true  → max = 9
    arr[1][1] = 4  → 4 > 9? false → max = 9 유지
    arr[1][2] = 1  → 1 > 9? false → max = 9 유지
    
    최종 결과: max = 9
  4. 초기화 방법 비교

    // ✅ 올바른 방법
    int max = arr[0][0];  // 첫 요소로 초기화
    
    // ❌ 잘못된 방법
    int max = 0;  // 만약 배열에 음수만 있다면?
    // 예: {-5, -3, -1} → max는 0이 되지만, 실제 최대값은 -1
  5. 최소값 찾기 (참고)

    int min = arr[0][0];
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            if (arr[i][j] < min) {  // 부등호만 반대
                min = arr[i][j];
            }
        }
    }

✅ 문제 5: 3×3 배열에 1~9 저장하기 (중요 ⭐)

문제

3×3 이차원 배열을 생성하고 1부터 9까지 차례대로 저장한 뒤 출력하세요.

출력 예

1 2 3
4 5 6
7 8 9

정답 코드

public class Ex5 {
    public static void main(String[] args) {
        int[][] arr = new int[3][3];
        int num = 1;  // 1부터 시작하는 숫자

        // 배열에 값 저장
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = num++;
            }
        }

        // 배열 출력
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

풀이 설명

  1. 배열 생성

    int[][] arr = new int[3][3];
    • 3행 3열의 빈 배열 생성 (모든 값은 0으로 초기화)
  2. 숫자 증가 변수

    int num = 1;  // 1부터 시작
  3. 값 저장 과정

    arr[i][j] = num++;
    • num++후위 증가 연산자
    • 현재 num 값을 먼저 대입한 후, 1을 증가시킴
  4. 실행 과정 상세

    초기값: num = 1
    
    i=0 (첫 번째 행):
      j=0: arr[0][0] = num++  → arr[0][0] = 1, num = 2
      j=1: arr[0][1] = num++  → arr[0][1] = 2, num = 3
      j=2: arr[0][2] = num++  → arr[0][2] = 3, num = 4
    
    i=1 (두 번째 행):
      j=0: arr[1][0] = num++  → arr[1][0] = 4, num = 5
      j=1: arr[1][1] = num++  → arr[1][1] = 5, num = 6
      j=2: arr[1][2] = num++  → arr[1][2] = 6, num = 7
    
    i=2 (세 번째 행):
      j=0: arr[2][0] = num++  → arr[2][0] = 7, num = 8
      j=1: arr[2][1] = num++  → arr[2][1] = 8, num = 9
      j=2: arr[2][2] = num++  → arr[2][2] = 9, num = 10
  5. 최종 배열 상태

    arr = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    }
  6. 시각적 표현

    ┌─────┬─────┬─────┐
    │  1  │  2  │  3  │  ← 첫 번째 행
    ├─────┼─────┼─────┤
    │  4  │  5  │  6  │  ← 두 번째 행
    ├─────┼─────┼─────┤
    │  7  │  8  │  9  │  ← 세 번째 행
    └─────┴─────┴─────┘
  7. 다른 초기값으로 시작하기

    int num = 10;  // 10부터 시작
    // 결과: 10 11 12 / 13 14 15 / 16 17 18
    
    int num = 0;  // 0부터 시작
    // 결과: 0 1 2 / 3 4 5 / 6 7 8
  8. num++ vs ++num

    // 후위 증가 (num++)
    arr[i][j] = num++;  // 먼저 대입, 후에 증가
    
    // 전위 증가 (++num)
    arr[i][j] = ++num;  // 먼저 증가, 후에 대입
    // 결과: 2 3 4 / 5 6 7 / 8 9 10 (1부터 시작 안 함!)

🔥 전체 핵심 정리

1. 이차원 배열 기본 구조

int[][] arr = {
    {값1, 값2, 값3},
    {값4, 값5, 값6}
};

// 접근: arr[행인덱스][열인덱스]
arr[0][0]  // 첫 번째 행, 첫 번째 열
arr[1][2]  // 두 번째 행, 세 번째 열

2. 이중 for문 패턴

for (int i = 0; i < arr.length; i++) {        // 행 순회
    for (int j = 0; j < arr[i].length; j++) {  // 열 순회
        // arr[i][j] 처리
    }
}

3. 주요 속성

속성 의미 예시
arr.length 행의 개수 3
arr[i].length i번째 행의 열 개수 각 행마다 다를 수 있음

4. 변수 초기화 위치 ⭐

문제 유형 변수 위치 예시
전체 합/최대값 바깥쪽 반복문 int sum = 0; (밖에)
행별 합 안쪽 반복문 int sum = 0; (i 반복문 안)
최대/최소값 첫 요소로 초기화 int max = arr[0][0];

5. 자주 사용하는 패턴

패턴 1: 배열 출력

for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}

패턴 2: 전체 합

int sum = 0;
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        sum += arr[i][j];
    }
}

패턴 3: 행별 합

for (int i = 0; i < arr.length; i++) {
    int sum = 0;  // 각 행마다 초기화
    for (int j = 0; j < arr[i].length; j++) {
        sum += arr[i][j];
    }
    System.out.println((i + 1) + "행 합: " + sum);
}

패턴 4: 최대값 찾기

int max = arr[0][0];
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        if (arr[i][j] > max) {
            max = arr[i][j];
        }
    }
}

패턴 5: 순차적으로 값 채우기

int num = 1;
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        arr[i][j] = num++;
    }
}

💡 연습 문제 추가 도전

도전 1: 열별 합 구하기

각 열의 합을 구하여 출력하세요.

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6}
};
// 출력: 1열 합: 5, 2열 합: 7, 3열 합: 9

도전 2: 대각선 합 구하기

왼쪽 위에서 오른쪽 아래로 가는 대각선의 합을 구하세요.

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
// 출력: 대각선 합: 15 (1 + 5 + 9)

도전 3: 배열 뒤집기

행의 순서를 뒤집어 출력하세요.

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6}
};
// 출력: 4 5 6 / 1 2 3

📝 학습 체크리스트

다음을 모두 이해했다면 이차원 배열을 마스터한 것입니다!

  • 이차원 배열 선언과 초기화 방법
  • arr.lengtharr[i].length의 차이
  • 이중 for문으로 모든 요소 접근
  • 전체 합을 구하는 방법
  • 행별 합을 구할 때 변수 초기화 위치
  • 최대값/최소값 찾기 (초기화 방법)
  • 순차적으로 값 채우기 (num++ 활용)
  • 이차원 배열을 행렬처럼 출력하기