Kotlinで理解する！二次元配列の使い方20選

はじめに
●Kotlinとは
- ○Kotlinの特徴
- ○Kotlinの歴史
●二次元配列の基本
- ○二次元配列とは
- ○Kotlinでの二次元配列の宣言方法
●二次元配列の使い方
●二次元配列の応用例
●注意点と対処法
●カスタマイズ方法
まとめ

はじめに

皆さんはKotlinというプログラミング言語をご存知ですか？

Javaと同じくJVM上で動作する言語で、特にAndroidアプリの開発で人気を集めています。

今回は、そんなKotlinでの「二次元配列」の使い方を徹底的に解説していきます。

この記事を読めば、Kotlinでの二次元配列の生成から応用まで、しっかりと理解することができるようになります。

●Kotlinとは

Kotlinは、JetBrains社が開発した静的型付けのプログラミング言語です。

Javaよりも簡潔で、より安全性を持ち合わせた言語として開発されました。

Kotlinは特にAndroidの公式開発言語としても認定され、多くの開発者に支持されています。

○Kotlinの特徴

Kotlinの最大の特徴は、Javaとの高い互換性を持ちながら、より簡潔で直感的なコードを書くことができる点にあります。

Javaで書かれたライブラリやフレームワークをそのまま利用できるので、既存のJavaのプロジェクトにKotlinを取り入れることも容易です。

また、Kotlinはnull安全な設計になっており、不必要なランタイムエラーを大幅に削減することができます。

○Kotlinの歴史

Kotlinは2011年に初めて公開されました。

その後、Googleが2017年のGoogle I/OでAndroidの公式言語としてKotlinを採用することを発表。

それにより、Kotlinの普及が急速に進みました。

Javaの後継ともいえるこの言語は、現在も多くの開発者に支持され、さまざまなアプリケーションやシステムで利用されています。

Kotlinは、開発者が直面する問題を効率的に解決するための多くの特徴や機能を持ち合わせています。

特に二次元配列の取り扱いも、Javaよりも直感的で簡潔に記述することができる点が魅力となっています。

●二次元配列の基本

○二次元配列とは

二次元配列とは、名前の通り、配列の中に配列が存在する構造のことを指します。

平易に言うと、表形式のデータをプログラム上で扱う際に非常に便利なデータ構造となります。

例えば、Excelのような行と列を持つデータや、ゲームのマップ情報などを扱う際に使用します。

一次元配列が一直線のような構造を持つのに対して、二次元配列は格子状、すなわち「行」と「列」の二つの次元を持っています。

○Kotlinでの二次元配列の宣言方法

Kotlinで二次元配列を宣言する方法はいくつかありますが、一般的な宣言と初期化の方法を紹介します。

まずは、Int型の二次元配列を宣言し、初期化する例です。

// 3行3列の二次元配列を宣言し、初期化
val array2D: Array<Array<Int>> = Array(3) { Array(3) { 0 } }

このコードでは、3×3の大きさを持つ二次元配列を作成し、すべての要素を0で初期化しています。

// array2Dの中身を表示
for (row in array2D) {
    for (value in row) {
        print("$value ")
    }
    println()
}

上記のコードを実行すると、次のように表示されます。

0 0 0 
0 0 0 
0 0 0

このように、KotlinではArrayクラスを使用して二次元配列を簡単に宣言・初期化することができます。

また、for文を使って二次元配列の内容を繰り返し処理することも可能です。

●二次元配列の使い方

Kotlinを使った二次元配列の使い方を深掘りしていきます。

二次元配列は、プログラミングの世界において非常に一般的なデータ構造であり、様々な場面での使用が想定されます。

Kotlinでの実装方法やその応用例を、サンプルコードを交えて説明します。

○サンプルコード1：基本的な二次元配列の生成と表示

Kotlinでの二次元配列の生成は直感的です。

ここでは、5×5のInt型二次元配列を生成し、初期化して表示するサンプルコードを紹介します。

// 5行5列の二次元配列を生成して初期化
val matrix = Array(5) { IntArray(5) { it } }

// matrixの内容を表示
for (row in matrix) {
    for (num in row) {
        print("$num ")
    }
    println()
}

このコードでは、5×5の二次元配列を作成し、各要素を0から4の数字で初期化しています。

その後、二重のfor文を使って内容を表示しています。

実行すると、0から4までの数字が5行分表示されます。

○サンプルコード2：二次元配列の要素にアクセスする

二次元配列の各要素にアクセスする方法も簡単です。

下記のサンプルコードでは、3×3の二次元配列を生成し、中央の要素にアクセスして値を更新する例を表しています。

// 3行3列の二次元配列を生成
val matrix2 = Array(3) { IntArray(3) { it + 1 } }

// matrix2の中央の要素にアクセスして値を99に更新
matrix2[1][1] = 99

// 更新後のmatrix2の内容を表示
for (row in matrix2) {
    for (num in row) {
        print("$num ")
    }
    println()
}

このコードでは、3×3の二次元配列を作成し、初期化しています。

その後、中央の要素(matrix2[1][1])を99に更新しています。

最後にその内容を表示すると、中央の要素だけが99になっていることが確認できます。

○サンプルコード3：二次元配列の要素の更新

二次元配列の要素を更新する方法も非常に簡単です。

任意の行や列を指定して、新しい値に更新することができます。

下記のサンプルコードは、4×4のInt型二次元配列を生成し、特定の要素を更新するものです。

// 4行4列の二次元配列を生成して初期化
val array2D = Array(4) { IntArray(4) { (it + 1) * (it + 1) } }

// 二次元配列の[2][2]の要素を77に更新
array2D[2][2] = 77

// 更新した二次元配列を表示
for (row in array2D) {
    for (value in row) {
        print("$value ")
    }
    println()
}

このコードでは、4×4の二次元配列を作成しており、各要素をその要素のインデックスの二乗で初期化しています。

その後、特定の位置である[2][2]の要素を77に更新しています。

最後に二重のfor文を使って更新後の配列の内容を表示しています。

このコードを実行すると、ほとんどの要素はインデックスの二乗の値が表示されますが、[2][2]の位置だけ77が表示されることが確認できます。

○サンプルコード4：二次元配列のサイズ取得

Kotlinで二次元配列のサイズを取得する方法も提供されています。

配列の.sizeプロパティを使用すると、行の数を取得でき、特定の行の.sizeプロパティを使用すると、その行の列の数を取得できます。

下記のサンプルコードでは、3×5のInt型二次元配列を生成し、そのサイズを表示するものです。

// 3行5列の二次元配列を生成
val matrix3 = Array(3) { IntArray(5) { 0 } }

// 配列の行数と列数を取得して表示
val rows = matrix3.size
val cols = matrix3[0].size

println("行数: $rows, 列数: $cols")

このコードを実行すると、行数が3、列数が5であることが表示されます。

このように、Kotlinでは二次元配列のサイズを簡単に取得することができます。

○サンプルコード5：二次元配列のループ処理

二次元配列の要素を一つずつ取得して処理を行いたい場合、ループ処理が必要となります。

Kotlinでは、for文を用いて二次元配列のループ処理を簡単に実行することができます。

ここでは、3×3のInt型二次元配列を生成し、そのすべての要素を表示するサンプルコードを紹介します。

// 3x3の二次元配列を生成して初期化
val array2DLoop = Array(3) { row -> IntArray(3) { col -> (row + 1) * (col + 1) } }

// すべての要素を表示
for (row in array2DLoop) {
    for (value in row) {
        print("$value ")
    }
    println()
}

このコードでは、3×3の二次元配列を生成しています。

各要素は、行インデックスに1を足した値と列インデックスに1を足した値の乗算で初期化されます。

そして、二重のfor文を用いて、すべての要素を表示しています。

このコードを実行すると、次のような結果が出力されます。

1 2 3
2 4 6
3 6 9

ここからわかるように、Kotlinでは二次元配列のすべての要素を順番に取得して処理するために、外側のfor文で行を取得し、内側のfor文で各行の列の要素を取得するという方法でループ処理を実装します。

●二次元配列の応用例

二次元配列は、その特性上、様々なアプリケーションや問題解決のシナリオで非常に有用です。

Kotlinでの二次元配列の応用例をいくつか見てみましょう。

○サンプルコード6：行と列の合計を求める

行や列ごとの合計を求める際、二次元配列は直感的にこの種の計算をサポートします。

val matrix = arrayOf(
    intArrayOf(1, 2, 3),
    intArrayOf(4, 5, 6),
    intArrayOf(7, 8, 9)
)

// 行の合計を求める
for (row in matrix) {
    println("行の合計: ${row.sum()}")
}

// 列の合計を求める
for (col in matrix[0].indices) {
    var sum = 0
    for (row in matrix) {
        sum += row[col]
    }
    println("列${col + 1}の合計: $sum")
}

このコードを使用して行の合計と列の合計を計算します。

行の合計を求めるためには、各行の要素のsum関数を使用するだけで十分です。

一方、列の合計を求めるには、列のインデックスをループして、各行の該当する列の要素を加算する必要があります。

このコードを実行すると、行の合計が6、15、24、そして列の合計が12、15、18と表示されることが期待されます。

○サンプルコード7：二次元配列を使用した行列の掛け算

線形代数の基本操作の1つである行列の掛け算を実現するには、二次元配列が最適です。

val matrixA = arrayOf(
    intArrayOf(1, 2),
    intArrayOf(3, 4)
)

val matrixB = arrayOf(
    intArrayOf(2, 0),
    intArrayOf(1, 3)
)

val resultMatrix = Array(2) { IntArray(2) }

for (i in matrixA.indices) {
    for (j in matrixB[0].indices) {
        for (k in matrixB.indices) {
            resultMatrix[i][j] += matrixA[i][k] * matrixB[k][j]
        }
    }
}

// 結果を表示
for (row in resultMatrix) {
    for (value in row) {
        print("$value ")
    }
    println()
}

行列の掛け算を行うために、3つのネストされたループを使用します。

最外部の2つのループは、結果行列の各要素にアクセスします。

内部のループは、掛け算の実際の計算を行います。

このコードを実行すると、4 6 と 10 12 の行列が得られることが期待されます。

○サンプルコード8：二次元配列を使ったゲームボードの作成

多くのボードゲームやパズルゲームは、二次元の格子状のフィールド上で進行します。

このようなゲームの開発には、二次元配列が非常に適しています。

二次元配列を使用すれば、ゲームのフィールドを表現し、その上での操作を簡単に実現できます。

以下のコードは、3×3のシンプルなゲームボードを作成し、それを表示するものです。

このボードは、例として「O」、「X」、空（” “）の3つの状態を持つセルで構成されています。

// 3x3のゲームボードの初期化
val gameBoard = arrayOf(
    arrayOf("O", "X", "O"),
    arrayOf(" ", "X", "X"),
    arrayOf("O", " ", " ")
)

// ゲームボードの表示
for (row in gameBoard) {
    for (cell in row) {
        print("$cell | ")
    }
    println("\n---------")
}

このコードでは、3×3の二次元配列を使ってゲームボードを定義しています。

そして、二重のforループを使って、ゲームボードの各セルを順に表示しています。

このコードを実行すると、次のようにゲームボードが表示されます。

O | X | O |
---------
  | X | X |
---------
O |   |   |
---------

このシンプルな例を元に、ゲームのロジックやユーザーの入力を組み合わせることで、完全なボードゲームを作成することができます。

Kotlinの二次元配列を駆使することで、独自のゲームやアプリケーションの開発が格段に簡単になります。

○サンプルコード9：二次元配列を使って画像データを模倣

二次元配列は、画像データのように、情報が格子状に配置されているデータを扱うのに適しています。

下記のコードは、5×5のモノクロ画像（0は白、1は黒とする）を二次元配列で表現し、その画像データを表示する例です。

val image = arrayOf(
    intArrayOf(0, 0, 1, 0, 0),
    intArrayOf(0, 1, 0, 1, 0),
    intArrayOf(1, 0, 0, 0, 1),
    intArrayOf(0, 1, 0, 1, 0),
    intArrayOf(0, 0, 1, 0, 0)
)

for (row in image) {
    for (pixel in row) {
        if (pixel == 0) {
            print("□ ")
        } else {
            print("■ ")
        }
    }
    println()
}

このコードを実行すると、中央にクロス模様が描かれた5×5のモノクロ画像が表示されることが期待されます。

二次元配列を使用することで、このようなシンプルな画像データやパターンを効果的に表現することができます。

○サンプルコード10：動的に二次元配列を生成

ゲーム開発やデータ解析などの多岐にわたるプロジェクトで、二次元配列のサイズが固定ではなく、動的に変更する必要が生じることがあります。

Kotlinでは、動的にサイズを指定して二次元配列を生成することができます。

具体的には、ユーザーの入力や外部のデータに応じて、必要なサイズの二次元配列を生成するシナリオを想定してみましょう。

下記のサンプルコードは、ユーザーに行数と列数を入力してもらい、そのサイズの二次元配列を生成し、0で初期化します。

fun main() {
    println("行数を入力してください：")
    val rows = readLine()!!.toInt()

    println("列数を入力してください：")
    val cols = readLine()!!.toInt()

    // 入力された行数と列数で二次元配列を生成し、0で初期化
    val array = Array(rows) { IntArray(cols) { 0 } }

    // 二次元配列の内容を表示
    for (row in array) {
        for (value in row) {
            print("$value ")
        }
        println()
    }
}

このコードを使って、例えば3行4列の二次元配列を生成すると、次のような結果が得られます。

行数を入力してください：
3
列数を入力してください：
4
0 0 0 0 
0 0 0 0 
0 0 0 0

このように、Kotlinでの動的な二次元配列の生成は非常にシンプルに行えます。

ユーザーの要求や外部データに応じて適切なサイズの二次元配列を容易に準備できるので、柔軟なプログラム作成が可能となります。

○サンプルコード11：二次元配列を1次元配列に変換

データ処理の中で、二次元配列のデータを1次元配列に変換する必要が出てくることもあります。

この変換は、特定のアルゴリズムを適用したり、他のライブラリやツールとの互換性を持たせるために行われることが多いです。

下記のサンプルコードは、3×3の二次元配列を1次元配列に変換する例を表しています。

val twoDimArray = arrayOf(
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6),
    arrayOf(7, 8, 9)
)

val oneDimArray = twoDimArray.flatten()

// 変換結果の表示
println(oneDimArray)

このコードを実行すると、次のような変換結果が得られます。

[1, 2, 3, 4, 5, 6, 7, 8, 9]

このコードの中心的な部分はflatten()関数です。

この関数は、二次元配列を平坦化し、1次元のリストに変換するものです。

変換後のデータは1次元のリストとして得られるため、さまざまな操作が容易に行えます。

○サンプルコード12：二次元配列のソート

データ処理の際、配列の要素を順番に並べ替えることはよく行われます。

特に二次元配列の場合、行や列を基準にしてソートする必要があります。

Kotlinでは、これを簡単に実現できる方法が提供されています。

下記のサンプルコードは、二次元配列の各行を、その行の最初の要素を基準にして昇順にソートするものです。

val twoDimArray = arrayOf(
    arrayOf(5, 2, 3),
    arrayOf(1, 5, 6),
    arrayOf(4, 1, 9)
)

// 各行の最初の要素を基準に昇順ソート
val sortedArray = twoDimArray.sortedBy { it[0] }

// ソート結果の表示
for (row in sortedArray) {
    println(row.joinToString(", "))
}

このコードでは、sortedBy関数を使用しています。この関数の中のit[0]は、ソートの基準となる要素を指定しています。

この場合、各行の最初の要素がその基準となります。

このコードを実行すると、次のような結果が得られるでしょう。

1, 5, 6
4, 1, 9
5, 2, 3

Kotlinの強力な標準ライブラリを使用すれば、独自の基準でのソートも容易に実現できます。

例えば、行の合計や特定の列を基準にするといったソートも、少しのコード変更で対応することができるでしょう。

○サンプルコード13：二次元配列の深いコピーと浅いコピー

二次元配列をコピーする際、表面的なコピー（浅いコピー）と実際の要素までコピーする（深いコピー）の2つの方法が考えられます。

Kotlinでは、この2つの方法を明確に区別して使用することができます。

まず、浅いコピーの例を見てみましょう。

val originalArray = arrayOf(
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6)
)

// 浅いコピー
val shallowCopy = originalArray.clone()

originalArray[0][0] = 9

// コピー後の二次元配列の表示
for (row in shallowCopy) {
    println(row.joinToString(", "))
}

浅いコピーの場合、originalArrayの変更はshallowCopyにも影響します。

このコードを実行すると、次のような出力が得られます。

9, 2, 3
4, 5, 6

次に、深いコピーの例を見てみましょう。

val originalArray = arrayOf(
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6)
)

// 深いコピー
val deepCopy = originalArray.map { it.clone() }.toTypedArray()

originalArray[0][0] = 9

// コピー後の二次元配列の表示
for (row in deepCopy) {
    println(row.joinToString(", "))
}

このコードを実行すると、originalArrayの変更はdeepCopyに影響せず、次のような出力が得られるでしょう。

1, 2, 3
4, 5, 6

○サンプルコード14：二次元配列を使用したグラフの表現

グラフやネットワークのデータ構造は、二次元配列を使用して効率的に表現できます。

Kotlinでの実装は直感的であり、初心者でも簡単に理解できることでしょう。

考え方としては、グラフの各頂点を二次元配列の行または列として扱い、接続情報をその要素に格納します。

具体的には、頂点が接続されている場合は「1」、接続されていない場合は「0」として表現することが一般的です。

下記のサンプルコードでは、簡単な無向グラフの接続情報を二次元配列で表現しています。

// グラフの頂点数
val vertexNum = 5

// グラフの接続情報を二次元配列で表現
val graph = Array(vertexNum) { IntArray(vertexNum) { 0 } }

// 接続情報を追加
graph[0][1] = 1
graph[1][0] = 1
graph[1][2] = 1
graph[2][1] = 1
graph[2][3] = 1
graph[3][2] = 1
graph[3][4] = 1
graph[4][3] = 1

// グラフの接続情報を表示
for (i in 0 until vertexNum) {
    for (j in 0 until vertexNum) {
        print("${graph[i][j]} ")
    }
    println()
}

このコードの中で、Array関数を使用して、グラフの頂点数に応じた二次元配列を初期化しています。

次に、各頂点間の接続情報を設定する部分で、接続されている頂点のペアに「1」を設定しています。

このコードを実行すると、次のような出力が得られます。

この結果から、0番目の頂点と1番目の頂点、1番目の頂点と2番目の頂点、などが接続されていることがわかります。

○サンプルコード15：二次元配列のリストへの変換

二次元配列をリストのリストへ変換するケースもあります。

特にKotlinでは、リストを用いることでさまざまな関数や操作が利用できるため、このような変換が非常に便利です。

下記のサンプルコードは、二次元配列をリストのリストに変換する一例です。

val twoDimArray = arrayOf(
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6),
    arrayOf(7, 8, 9)
)

// 二次元配列をリストのリストに変換
val twoDimList = twoDimArray.map { it.toList() }

// 変換後のリストを表示
twoDimList.forEach { row ->
    println(row.joinToString(", "))
}

このコードの中で、map関数を使用して、各行をリストに変換しています。

その結果、二次元のリストが生成されます。

このコードを実行すると、次のような結果が得られるでしょう。

1, 2, 3
4, 5, 6
7, 8, 9

リストに変換することで、Kotlinの強力なリスト操作関数を使用して、さまざまな処理や操作を行うことができるようになります。

●注意点と対処法

Kotlinで二次元配列を扱う際には、いくつかの注意点が存在します。

これらの注意点を理解しておくことで、バグや予期しない動作を避けることができます。

ここでは、主な注意点とその対処法について詳しく解説します。

○二次元配列のメモリ使用について

二次元配列は、一般的にメモリ上で連続的な領域を使用します。

そのため、大きな二次元配列を生成する際には、メモリの消費量が増加します。

特に、アプリケーションで大量のデータを扱う場合やモバイルデバイスなど、メモリリソースが限られている環境での利用に注意が必要です。

対処法として、二次元配列のサイズが不要に大きくならないように、最適なサイズでの宣言を心掛けることが重要です。

また、不要になった配列は速やかに参照を切り離し、ガーベージコレクションの対象とすることも効果的です。

○null値の扱い方

Kotlinでは、型によってnullを許容するかどうかが決まっています。

例えば、IntArrayはnullを持つことができませんが、Array<Int?>はnull値を持つことが可能です。

そのため、nullを扱う際は、適切な型を選択することが重要です。

また、null値を持つ可能性がある場合、その扱いには特に注意が必要です。

下記のサンプルコードは、nullを含む二次元配列の初期化とアクセス方法を表しています。

val matrix: Array<Array<Int?>> = Array(3) { arrayOfNulls<Int?>(3) }

matrix[0][0] = 1
matrix[1][1] = 2
matrix[2][2] = 3

for (row in matrix) {
    for (value in row) {
        print(value?.toString() ?: "null")
        print(" ")
    }
    println()
}

このコードでは、arrayOfNulls関数を使用して、nullで初期化された二次元配列を生成しています。

アクセス時には、エルビス演算子?.を使用してnull安全に操作を行っています。

このコードを実行すると、次のような出力が得られるでしょう。

1 null null 
null 2 null 
null null 3

○型の不一致に関する注意

Kotlinは静的型付け言語であるため、型の不一致はコンパイルエラーとなります。

特に、ジェネリックを使用する際や、異なる型の値を代入しようとした場合には注意が必要です。

また、型推論を利用する際も、意図しない型として推論されることがあるため、宣言時に型を明示することを推奨します。

例えば、整数と浮動小数点数を混在させた二次元配列を作成しようとすると、次のようなコードが考えられます。

val mixedArray = arrayOf(
    arrayOf(1, 2.0, 3),
    arrayOf(4, 5.5, 6)
)

しかし、このコードはエラーとなります。

正しくは、Any型や共通のスーパータイプを使用するなどの方法で、型の不一致を解消する必要があります。

●カスタマイズ方法

Kotlinでは、拡張関数や拡張プロパティを使用して、既存のクラスに新しい機能を追加することができます。

これを利用することで、二次元配列に関する便利なメソッドやプロパティを追加し、カスタマイズすることが可能です。

○サンプルコード16：拡張関数を使用して二次元配列の機能を拡張

下記のサンプルコードは、二次元配列にsumAllという拡張関数を追加して、全要素の合計値を取得する例です。

fun Array<IntArray>.sumAll(): Int {
    return this.sumBy { it.sum() }
}

fun main() {
    val array2D = arrayOf(
        intArrayOf(1, 2, 3),
        intArrayOf(4, 5, 6),
        intArrayOf(7, 8, 9)
    )

    println("二次元配列の全要素の合計：${array2D.sumAll()}")
}

このコードでは、Array<IntArray>に対してsumAll関数を追加しています。

実行すると、二次元配列の全要素の合計値が出力されます。

○サンプルコード17：二次元配列の表示形式をカスタマイズ

二次元配列の要素を整形して表示する際、特定のフォーマットに従って表示したいことがあります。

下記のサンプルコードは、拡張関数を使用して二次元配列を指定したフォーマットで文字列に変換する方法を表しています。

fun Array<IntArray>.toFormattedString(): String {
    return this.joinToString(separator = "\n") { it.joinToString(separator = " | ") }
}

fun main() {
    val array2D = arrayOf(
        intArrayOf(1, 2, 3),
        intArrayOf(4, 5, 6),
        intArrayOf(7, 8, 9)
    )

    println(array2D.toFormattedString())
}

このコードでは、toFormattedStringという拡張関数を追加し、それを使用して整形された文字列を取得しています。

実行すると、各行が改行で、各要素が|で区切られて表示されます。

○サンプルコード18：二次元配列の操作を簡易化する拡張

Kotlinにおける拡張関数を駆使することで、二次元配列の操作をさらに簡易化することが可能です。

例えば、特定の値を持つ要素の位置を探す、あるいはその逆の操作など、頻繁に使用するであろうメソッドを自ら追加することができます。

ここでは、二次元配列から特定の値を持つ要素の位置（行と列）を返す拡張関数の例を紹介します。

fun Array<IntArray>.findPosition(value: Int): Pair<Int, Int>? {
    for (row in this.indices) {
        for (col in this[row].indices) {
            if (this[row][col] == value) {
                return Pair(row, col)
            }
        }
    }
    return null
}

fun main() {
    val array2D = arrayOf(
        intArrayOf(1, 2, 3),
        intArrayOf(4, 5, 6),
        intArrayOf(7, 8, 9)
    )

    val position = array2D.findPosition(5)
    if (position != null) {
        println("値が5である要素の位置は、行：${position.first}、列：${position.second}です。")
    } else {
        println("指定した値の要素は存在しません。")
    }
}

このコードでは、findPosition関数を用いて値が5である要素の行と列の位置を取得しています。

この関数は、要素が見つかればその位置をPairとして返し、見つからなければnullを返します。

○サンプルコード19：二次元配列を使用した独自クラスの作成

二次元配列は、多様なアプリケーションやゲームの内部データ表現にも活用されます。

そのような場面で、特定の操作を簡易に行いたい場合、二次元配列を内包する独自のクラスを作成することが考えられます。

ここでは、ゲームボードを模倣するための独自クラスのサンプルを紹介します。

class GameBoard(private val rows: Int, private val cols: Int) {
    private val board: Array<IntArray> = Array(rows) { IntArray(cols) { 0 } }

    fun setPiece(row: Int, col: Int, value: Int) {
        if (row in 0 until rows && col in 0 until cols) {
            board[row][col] = value
        }
    }

    fun getPiece(row: Int, col: Int): Int? {
        return if (row in 0 until rows && col in 0 until cols) {
            board[row][col]
        } else null
    }

    fun displayBoard() {
        for (row in board) {
            println(row.joinToString(" "))
        }
    }
}

fun main() {
    val game = GameBoard(3, 3)
    game.setPiece(1, 1, 5)
    game.displayBoard()
}

このコードでは、ゲームボードを模倣するGameBoardクラスを作成しました。

このクラスには、駒を配置するsetPieceメソッドや駒を取得するgetPieceメソッド、そしてボードの状態を表示するdisplayBoardメソッドがあります。

実行すると、中央に5が配置された3×3のゲームボードが表示されます。

○サンプルコード20：二次元配列をもとに3Dグラフィックの作成

3Dグラフィックはビジュアル表現の中で非常に強力な手段となります。

特にデータの視覚化では、三次元の空間にデータをマッピングすることで、そのデータの特性やパターンを一目瞭然とさせることができます。

二次元配列のデータを3Dグラフィックに変換することで、データの深さや高さを表現することが可能です。

下記のサンプルコードは、Kotlinを使って二次元配列のデータを基に3Dのグラフを作成するシンプルな例を表しています。

// 3Dグラフィックのライブラリやフレームワークが必要
// ここでは仮のコードとして表します

class ThreeDGraph(data: Array<IntArray>) {
    private val graphData = data

    // 3Dグラフを表示するメソッド
    fun displayGraph() {
        // 二次元配列のデータをもとに3Dグラフィックを描画
        for (i in graphData.indices) {
            for (j in graphData[i].indices) {
                drawCube(i, j, graphData[i][j]) // x, y, zの位置に立方体を描画する仮定
            }
        }
    }

    // 立方体を描画するメソッド（仮）
    private fun drawCube(x: Int, y: Int, z: Int) {
        println("立方体を($x, $y, $z)の位置に描画")
    }
}

fun main() {
    val data2D = arrayOf(
        intArrayOf(1, 2, 3),
        intArrayOf(4, 5, 6),
        intArrayOf(7, 8, 9)
    )

    val graph = ThreeDGraph(data2D)
    graph.displayGraph()
}

このコードを実行すると、指定した二次元配列の各要素をz座標として、xとyの位置に立方体が描画されることを想定しています。

具体的な3Dグラフィックの描画には外部ライブラリやフレームワークが必要ですが、このコードはそのような描画処理を省略して、概念的な部分だけを表しています。