[Java] for文の二重ループと二次元配列の組み合わせ

Javaのfor文の二重ループと二次元配列の組み合わせを、九九の計算を例にしながら整理。

二次元配列とfor文のネスト構造の使われ方についてもそれぞれ解説する。

[][]の重なり→二次元配列の宣言
for文にfor文が重なる形→for文のネスト構造

この二つの概念はペアで使われることが多い。

0.1 そもそも二次元配列とfor文のネスト構造とは？
- 0.1.1 二次元配列
- 0.1.2 for文のネスト構造
0.2 ペアで使うメリット
0.3 組み合わせのプログラムの例
0.4 どういう風に実行されているのか

1 配列と繰り返し処理についての関連記事
2 全体像を把握する

そもそも二次元配列とfor文のネスト構造とは？

こちら二つの内容については、別途別の記事で整理した。

二次元配列

二次元配列は、ようするにx軸とy軸で箱を用意するイメージ。

[][]を二つつけて配列を宣言することで、「2次元配列」を宣言することができるのだった。

//二次元配列を宣言するときの例
int[][] numbers;
String[][] mountains;

詳しくは下記を参照。

for文のネスト構造

また、for文のネスト構造については、for文にfor文を重ねることができるというものだった。

簡単な例文プログラムとしては、下記のようなものがある。

public class Main{
    public static void main(String[] args){
        for(int i = 0; i < 3; i++){
        System.out.println(i);
            for(int j = 0; j < 3; j++){
                System.out.println("★"+j);
             }    
        }   
    }
}

下記のように出力される。星がついている数字が、2つ目のfor文で出力された数字となる。

//出力結果
0
★0
★1
★2
1
★0
★1
★2
2
★0
★1
★2

詳細はこちら。

ペアで使うメリット

ではこの二つで何ができるのか？

多次元配列でデータを入れた時、for文のネスト構造で多次元配列の全ての要素にいっぺんにアクセスできることがメリットとなる。

組み合わせのプログラムの例

例として、九九の計算結果を出してみる。

public class Main{
    public static void main(String[] args){
        int[][] timesTable = new int[9][9];
        
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                timesTable[i][j] = (i + 1) * (j + 1);
            }
        }
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                System.out.print(timesTable[i][j] + "\t" );
            }
            System.out.println();
        }
    }
}

//出力結果
1	2	3	4	5	6	7	8	9	
2	4	6	8	10	12	14	16	18	
3	6	9	12	15	18	21	24	27	
4	8	12	16	20	24	28	32	36	
5	10	15	20	25	30	35	40	45	
6	12	18	24	30	36	42	48	54	
7	14	21	28	35	42	49	56	63	
8	16	24	32	40	48	56	64	72	
9	18	27	36	45	54	63	72	81

どういう風に実行されているのか

順にどのように実行されていくかを見ていく。

1.二次元配列の実行

二次元配列を宣言し、timesTableという変数に入れる。

int[][] timesTable = new int[9][9];

すると、下記画像のように、9行9列の要素を入れることができる二次元配列ができる。

2.for文のネスト構造を作成

9行9列の要素を入れることができる二次元配列「timesTable[ ][ ]」の箱ができた。

順番に計算して、結果をtimesTable[i][j]に格納していく。

下記のようなfor文のネスト構造を作成する。

for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                timesTable[i][j] = (i + 1) * (j + 1);
            }
        }

ここで注意なのは、for文の結果は0から始まることを考慮すること。

(i + 1) * (j + 1)となっているのは、for文の結果は0から始まるから。

九九での最初は1 × 1で始まる。けれども、for文では最初の数字は0で設定している。

なのでどちらも＋１することで、[0][0]の箱に、1×1の結果が入るように数字を合わせている。

[i]が縦、[j]が横列だと思ってもらうと良い。

3. 1の段から順番に処理が開始される

実行すると、1の段から順番に処理が実行されていく。

[i]の1回目の処理：

[ i ] が 0 で [ j ]が 0→ (0 + 1) * (0 + 1) = 1
[ i ] が 0 で [ j ]が 1→ (0 + 1) * (0 + 2) = 2
[ i ] が 0 で [ j ]が 2→ (0 + 1) * (0 + 3) = 3

というように続く。

すると、以下の画像のように、二次元配列の箱に数字が格納される。

[ j ]の繰り返し処理が9終わり、[ i ] の処理が1回終わると、今度は [i] の2回目の処理が始まる。

[i]の2回目の処理：

[ i ] が 1 で [ j ]が 0→ (1 + 1) * (0 + 1) = 2
[ i ] が 1 で [ j ]が 1→ (1 + 1) * (0 + 2) = 4
[ i ] が 1 で [ j ]が 2→ (1 + 1) * (0 + 3) = 6

というように、[j]の処理が終わるまで続く。

すると、以下のように数字が格納される。

これが続いていき、[i]の処理が9回続くまで処理が続く。

4. 出力

同じような処理の流れで、出力も行う。

“\t”は単純にスペースを作っている。

 for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                System.out.print(timesTable[i][j] + "\t" );
            }
            System.out.println();
        }

このようにして、格納した81個の値を、for文のネスト構造でいっぺんにアクセスできる。

再度、コードと結果を下記に共有する。

public class Main{
    public static void main(String[] args){
        int[][] timesTable = new int[9][9];
        
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                timesTable[i][j] = (i + 1) * (j + 1);
            }
        }
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                System.out.print(timesTable[i][j] + "\t" );
            }
            System.out.println();
        }
    }
}

//出力結果
1	2	3	4	5	6	7	8	9	
2	4	6	8	10	12	14	16	18	
3	6	9	12	15	18	21	24	27	
4	8	12	16	20	24	28	32	36	
5	10	15	20	25	30	35	40	45	
6	12	18	24	30	36	42	48	54	
7	14	21	28	35	42	49	56	63	
8	16	24	32	40	48	56	64	72	
9	18	27	36	45	54	63	72	81