4. 자바 배열과 반복문 (4) 중첩 반복문

이번 포스트에서는 반복문을 이용해 중첩 배열을 탐색하는 법에 대해 다룬다.

예상 독자

• 자바를 배우고 싶은 누구나
• JDK와 IDE를 설치한 자바 학습자. ( 1. 자바 설치 및 개발환경 설정 )
• char를 공부한 자바 학습자. ( 2. 자바 변수와 자료형  (1) char )
• boolean을 공부한 자바 학습자. ( 2. 자바 변수와 자료형 (2) boolean )
• byte, short, int, long을 공부한 자바 학습자. ( 2. 자바 변수와 자료형 (3) byte, short, int, long )
• float과 double을 공부한 자바 학습자. ( 2. 자바 변수와 자료형 (4) float, double )
• if-else문의 사용 방법을 알고있는 자바 학습자. ( 3. 자바 조건문 (1) if-else )
• 자바 배열을 공부한 자바 학습자. ( 4. 자바 배열과 반복문 (1) 배열 )
• 자바 반복문을 공부한 자바 학습자. ( 4. 자바 배열과 반복문 (2) 반복문 )
• 자바 중첩 배열을 공부한 자바 학습자. ( 4. 자바 배열과 반복문 (3) 중첩 배열 )

목표

• 중첩 배열 반복문
• 중첩 반복문 (Nested 'for' Loop)

중첩 배열 반복

이전 포스트에서 연습하기를 충실히 했다면 아래와 같은 배열을 기억 할 수 있을 것이다.

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'}, 
                {'f', 'g', 'h', 'i', 'j'}, 
                {'k', 'l', 'm', 'n', 'o'}  
        };
    }
}

이 배열의 0번째, matrix[0] 안에 있는 배열을 반복하려면 어떻게 해야 하는가?

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'}, 
                {'f', 'g', 'h', 'i', 'j'}, 
                {'k', 'l', 'm', 'n', 'o'}  
        };

        char[] matrix0 = matrix[0]; // {'a', 'b', 'c', 'd', 'e'};
        System.out.println(matrix0);
    }
}

실행 결과:
abcde

이제 matrix0안에 있는 값들을 반복문을 이용해 하나하나 출력 하려면 어떻게 해야하는가?

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'}, 
                {'f', 'g', 'h', 'i', 'j'}, 
                {'k', 'l', 'm', 'n', 'o'}  
        };

        char[] matrix0 = matrix[0]; // {'a', 'b', 'c', 'd', 'e'};
        for(int i = 0; i < matrix0.length; i++) {
            System.out.println(matrix0[i]);
        }
    }
}

실행 결과:
a
b
c
d
e

matrix0 와 matrix[0]는 같은 배열을 가지고 있다. 따라서 우리는 matrix0을 쓸 이유가 없다. matrix0대신 matrix[0]를 직접 사용 해 보자.

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'}, 
                {'f', 'g', 'h', 'i', 'j'}, 
                {'k', 'l', 'm', 'n', 'o'}  
        };

        for(int i = 0; i < matrix[0].length; i++) {
            System.out.println(matrix[0][i]);
        }
    }
}

실행 결과:
a
b
c
d
e

matrix[0].length는 무엇인가? matrix[0]안에는 {'a', 'b', 'c', 'd', 'e'}라는 배열이 들어있다. 이 배열의 길이는 몇인가? 5이다 따라서 이 반복문은 0, 1, 2, 3, 4이렇게 i를 5번 반복 할 것이다. 미심쩍으면 matrix[0].length도 출력 해 보자.

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'},
                {'f', 'g', 'h', 'i', 'j'},
                {'k', 'l', 'm', 'n', 'o'}
        };

        System.out.println(matrix[0].length);
        for(int i = 0; i < matrix[0].length; i++) {
            System.out.println(matrix[0][i]);
        }
    }
}

실행 결과:
5
a
b
c
d
e

이번엔 matrix[1]에 있는 값들을 반복문으로 출력하고 싶다. 어떻게 해야 할까? 실행 결과가 다음과 같도록 바로 위의 코드를 수정하고 실행 해 봐라. 다음 코드를 보지 말고 혼자 5분 정도 생각 해 보고 여러가지 시도를 해 봐라.

5
f
g
h
i
j

코드를 수정 했으면 밑으로 내려가 자신의 코드와 예제 코드를 비교 해 보자.

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'},
                {'f', 'g', 'h', 'i', 'j'},
                {'k', 'l', 'm', 'n', 'o'}
        };

        System.out.println(matrix[1].length);
        for(int i = 0; i < matrix[1].length; i++) {
            System.out.println(matrix[1][i]);
        }
    }
}

matrix[1]에는 {'f', 'g', 'h', 'i', 'j'}가 들어있으므로 matrix[1]의 길이인 matrix[1].length를 한계값(i < matrix[1].length)으로 넣어주고 출력문에서도 matrix[1][i]를 출력하면 된다. 그렇다면 2번 인덱스에 있는 배열을 반복문으로 출력하고 싶다면 어떻게 하겠는가?

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'},
                {'f', 'g', 'h', 'i', 'j'},
                {'k', 'l', 'm', 'n', 'o'}
        };

        System.out.println(matrix[2].length);
        for(int i = 0; i < matrix[2].length; i++) {
            System.out.println(matrix[2][i]);
        }
    }
}

실행 결과:
5
k
l
m
n
o

위의 코드처럼 작성하면 matrix[2]의 배열을 for문을 이용해 출력 할 수 있다.

그렇다면 이제, j라는 변수를 새로 선언 해 원하는 인덱스의 배열을 출력 해 보자.

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'},
                {'f', 'g', 'h', 'i', 'j'},
                {'k', 'l', 'm', 'n', 'o'}
        };

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

    }
}

실행 결과:
5
a
b
c
d
e

j = 0이기 때문에 첫번째 예제처럼 matrix[0]안에 있는 배열을 반복해 출력함을 알 수 있다. 이제 j 를 1로 바꾸고 실행 해보라. j = 2로 바꾸고 실행 해 보라. j의 값을 바꾸면 matrix안에 존재하는 배열 중 원하는 배열을 출력 할 수 있음을 확인 할 수 있다.

그럼 0, 1, 2번 배열을 모두 for문으로 출력하려면 어떻게 하겠는가?

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'},
                {'f', 'g', 'h', 'i', 'j'},
                {'k', 'l', 'm', 'n', 'o'}
        };

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

        System.out.println("#########" + matrix[1].length);
        for(int i = 0; i < matrix[1].length; i++) {
            System.out.println(matrix[1][i]);
        }

        System.out.println("#########" + matrix[2].length);
        for(int i = 0; i < matrix[2].length; i++) {
            System.out.println(matrix[2][i]);
        }
    }
}

실행 결과:
#########5
a
b
c
d
e
#########5
f
g
h
i
j
#########5
k
l
m
n
o

이렇게 for문을 3번 반복하면 된다. 만약 matrix안에 100개의 배열이 들어있으면 어떻게 할 것인가? 저 for문 전체를 100번 반복하면 된다. 1000개의 배열이 들어있으면 어떻게 할 것인가? for문을 1000번 반복하면 된다. for문을 1000번 반복하고 싶다면 뒤로가기를 눌러도 좋다. 그렇지 않다면 아래로 넘어가, for문을 또 for문으로 감싸는, 중첩 for문에 대해 알아보자.

중첩 반복문 (Nested 'for' Loop)

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

System.out.println("#########" + matrix[1].length);
for(int i = 0; i < matrix[1].length; i++) {
    System.out.println(matrix[1][i]);
}

System.out.println("#########" + matrix[2].length);
for(int i = 0; i < matrix[2].length; i++) {
    System.out.println(matrix[2][i]);
}

위의 코드에서 변하는 부분과 변하지 않는 부분을 알아보자. 변하는 부분는 변수화 할것이고 변하지 않는 부분은 그대로 쓸 수 있다. 위 코드에서 변하는 부분은 딱 한 부분 뿐이다. 바로 0, 1, 2즉 matrix자체의 인덱스이다. (matrix는 3개의 배열을 가지고있는 배열이라는 것을 잊지 말자.)

우리는 아까 j라는 인덱스를 새로 선언하여 matrix내의 원하는 인덱스(0~2)의 배열을 출력했다. 마찬가지로 j를 이용해 할 수 있을까?

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'},
                {'f', 'g', 'h', 'i', 'j'},
                {'k', 'l', 'm', 'n', 'o'}
        };

        int j = 0;
        System.out.println("#########" + matrix[j].length);
        for(int i = 0; i < matrix[j].length; i++) {
            System.out.println(matrix[j][i]);
        }
        j = 1;
        System.out.println("#########" + matrix[j].length);
        for(int i = 0; i < matrix[j].length; i++) {
            System.out.println(matrix[j][i]);
        }
        j = 2;
        System.out.println("#########" + matrix[j].length);
        for(int i = 0; i < matrix[j].length; i++) {
            System.out.println(matrix[j][i]);
        }

    }
}

실행 결과:
#########5
a
b
c
d
e
#########5
f
g
h
i
j
#########5
k
l
m
n
o

각 반복문을 실행하기 전에 원하는 인덱스의 값으로 j의 값을 바꿔주면 내부 배열 중 원하는 배열로 반복문을 돌릴 수 있다. 여기까지 하고 나니 위의 코드가 뭔가 반복되는 것 같지 않은가? j를 빼면 모두 같은 코드이다! 따라서 우리는 아래처럼 j가 0~2까지 반복하는 새 반복문을 만들 수 있다.

public class Main {
    public static void main(String[] args) {
        char matrix[][] = new char[][]{
                {'a', 'b', 'c', 'd', 'e'},
                {'f', 'g', 'h', 'i', 'j'},
                {'k', 'l', 'm', 'n', 'o'}
        };

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

실행 결과는 위와 같으므로 생략.

껍데기만 봐 보자.

for(int j = 0; j < matrix.length; j++) {
   

}

무슨 뜻인가? j = 0에서 j가 matrix.length다 작으면 계속 반복하라는 뜻이다. 그리고 각 반복의 마지막 j++로 j를 하나씩 늘리라는 뜻이다. 그래서 j = 0에서 시작해서 1, 2로 늘어난다.

[중첩 반복문 참조 그림]

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

j = 0 이면 matrix[j]는 matrix[0]일 것이다. 그러므로 아래의 포문을 돌리는 것과 같은 효과를 낼 것이다. j = 1일 때는  마찬가지로, matrix[1], , j = 2일때는 matrix[2]를 참조 할 것이다.

for (int i = 0; i < matrix[0].length; i++) {
    System.out.println(matrix[0][i]);
}

끝

이번 포스팅을 통해서 중첩 반복문에 대해서 설명 해 보았다. 위와 같은 논리를 이용하면 2중 뿐만 아니라 3중, 4중, .. n중 반복문도 가능하다. 중첩 반복문은 프로그래밍 언어를 처음 접하는 사람에게는 어려운 개념일 수 있으므로 이해하는데 시간이 걸릴 수 있다. 실제로 내가 자문을 구한 초보자의 경우 matrix0에서 matrix[0]으로 넘어가는 부분에서 20분 넘게 걸렸으므로 한번 보고 바로 이해되지 않는다고 상심하지 말라. 연습 해 보고, 에러도 내 보면서 더 자세히 알아가게 될 것이다. 다음 포스트에서는 for문을 이용한 다양한 실습을 해보도록 한다.

다음 포스트 : 4. 자바 배열과 반복문 (4) 연습 - 배열의 최댓값 구하기