Skip to content

配列 ​

配列(Array)は、同じ型またはそのサブタイプの固定数の値を保持するデータ構造です。 配列の要素は順序付けされており、インデックスによってアクセスされます。

Kotlin は Array<T> クラスとプリミティブ型配列を提供しています。

配列を使用する場面 ​

Java API との相互運用性が必要な場合や、低レベルの要件がある場合に配列を使用します。例えば、一般的なアプリケーションで必要とされる以上のパフォーマンス要件がある場合や、カスタムデータ構造を構築する必要がある場合などです。

ほとんどのユースケースでは、代わりにコレクションを使用することをお勧めします。

機能配列コレクション
サイズ固定型による
読み取り専用バリアントなし(常に可変)あり(List および Set)
要素の追加と削除ネイティブサポートなし。
新しい配列を確保してコピーする
あり(可変コレクション)
== による構造的等価性なし(参照を比較)。
代わりに .contentEquals() を使用
あり
プリミティブ値プリミティブ型配列はボクシングなしで
値を格納する
通常はボクシングされる
Java との相互運用性T[] にマッピングされるjava.util.List および
java.util.Set にマッピングされる
関数型のフィルタリングと
変換
限定的豊富

配列をコレクションに変換する方法を学びましょう。

配列の作成 ​

配列を作成するには、以下を使用できます:

val で配列を宣言しても、変数の再代入が防止されるだけで、中身が読み取り専用になるわけではありません。 val 配列でも var 配列でも要素は変更可能です。この違いは参照にのみ影響し、中身には影響しません。 読み取り専用のビューが必要な場合は、代わりにコレクションを使用してください。

値を持つ配列 ​

既知の値のセットから型付き配列を作成するには、arrayOf() 関数を使用します。 Kotlin は型を自動的に推論します:

kotlin
fun main() {
    val simpleArray = arrayOf(1, 2, 3) // Array<Int>
    println(simpleArray.joinToString())
    // 1, 2, 3
}

空の配列 ​

要素を持たない配列を作成するには、emptyArray() 関数を使用します。 代入の左辺または右辺で要素の型を指定できます:

kotlin
val emptyArrayRight = emptyArray<String>()
val emptyArrayLeft: Array<String> = emptyArray()

配列に要素を追加する方法について学びましょう。

null を持つ配列 ​

null 要素で埋められた指定サイズの配列を作成するには、 arrayOfNulls() 関数を使用します:

kotlin
fun main() {
    val nullArray: Array<Int?> = arrayOfNulls(3)
    println(nullArray.joinToString())
    // null, null, null
}

Array コンストラクタ ​

Array コンストラクタは、配列のサイズと配列要素の値を返す関数を受け取ります:

kotlin
fun main() {
    val zeroes = Array<Int>(3) { 0 }
    println(zeroes.joinToString())
    // 0, 0, 0
    
    val squares = Array(5) { i -> i * i }
    println(squares.joinToString())
    // 0, 1, 4, 9, 16
}

ネストされた配列 ​

ネストされた配列(多次元配列)を作成するには、配列の配列を使用します。 ネストされた配列は、同じ型や同じサイズである必要はありません。

kotlin
fun main() {
    // 2次元配列を作成
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }
    println(twoDArray.contentDeepToString())
    // [[0, 0], [0, 0]]

    // 3次元配列を作成
    val threeDArray = Array(3) { Array(3) { Array<Int>(3) { 0 } } }
    println(threeDArray.contentDeepToString())
    // [[[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
}

プリミティブ型配列 ​

プリミティブ値に対して Array クラスを使用すると、コンパイラはそれらの値をオブジェクトにボクシングします。 ボクシングのオーバーヘッドを避けるために、専用のプリミティブ型配列を使用できます。 これらは Array<T> クラスのサブクラスではありませんが、同様の関数やプロパティのセットを提供します。

Kotlin の型対応する Java の型
BooleanArrayboolean[]
ByteArraybyte[]
CharArraychar[]
DoubleArraydouble[]
FloatArrayfloat[]
IntArrayint[]
LongArraylong[]
ShortArrayshort[]

Kotlin には専用の StringArray 型はありません。String はプリミティブではないため、 代わりに型推論を利用した arrayOf() や arrayOf<String>() 関数を使用してください。

プリミティブ型配列を作成するには、以下のいずれかのオプションを使用します:

  • コンストラクタ関数:

    kotlin
    fun main() {
        // 値が0に初期化されたサイズ5のInt配列を作成
        val primitiveTypeArray = IntArray(5)
        println(primitiveTypeArray.joinToString())
        // 0, 0, 0, 0, 0
    
        // Int配列を作成し、初期化関数を受け取る
        val squares = IntArray(5) { i -> i * i }
        println(squares.joinToString())
        // 0, 1, 4, 9, 16
    }
  • ファクトリ関数:

    kotlin
    fun main() {
        // 5つの要素を持つInt配列を作成
        val numbers = intArrayOf(1, 2, 3, 4, 5)
        println(numbers.joinToString())
        // 1, 2, 3, 4, 5
    
        // 3つの要素を持つChar配列を作成
        val characters = charArrayOf('K', 't', 'l')
        println(characters.joinToString())
        // K, t, l
    
        // 3つの要素を持つDouble配列を作成
        val doubles = doubleArrayOf(0.22, 4.16, 0.5)
        println(doubles.joinToString()) 
        // 0.22, 4.16, 0.5
    }

プリミティブ型配列をオブジェクト型配列に変換するには、.toTypedArray() 関数を使用します。

オブジェクト型配列をプリミティブ型配列に変換するには、.toBooleanArray()、 .toByteArray()、.toCharArray() などを使用します。

配列の操作 ​

配列は、反復処理(イテレーション)、検索、ソート、変換など、コレクションと同様の多くの操作をサポートしています。 Kotlin では、関数に可変長引数を渡すために配列を使用したり、配列自体に対して操作を実行したりできます。 最も一般的なプロパティと関数は以下の表のとおりです:

メンバー戻り値
size要素数
indices有効なインデックスの範囲
lastIndex最後の有効なインデックス
first() および last()最初と最後の要素
isEmpty() および isNotEmpty()配列が空または空でない場合に true
contains()配列にその要素が含まれている場合に true

配列のプロパティや関数の詳細については、API リファレンスを参照してください。

このセクションでは、最もよく使用される操作のいくつかを紹介します。

要素へのアクセスと変更 ​

配列の要素にアクセスして変更するには、インデックスアクセス演算子 ([])を使用します:

kotlin
fun main() {
    val simpleArray = arrayOf(1, 2, 3)
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }

    // 要素にアクセスして変更する
    simpleArray[0] = 10
    twoDArray[0][0] = 2

    // 変更された要素を出力する
    println(simpleArray[0]) 
    // 10
    println(twoDArray[0][0]) 
    // 2
}

配列の境界外のインデックスにアクセスしようとすると、Kotlin は実行時に ArrayIndexOutOfBoundsException をスローします。

また、fill(element, fromIndex, toIndex) 関数を使用して、 指定した範囲の要素をその場で置き換えることもできます。fromIndex は含まれ(inclusive)、toIndex は含まれません(exclusive):

kotlin
fun main() {
    val arr = IntArray(3)
    println(arr.joinToString())
    // 0, 0, 0
    
   arr.fill(1)
   println(arr.joinToString())
   // 1, 1, 1
  
   arr.fill(0, 0, 2)
   println(arr.joinToString())
   // 0, 0, 1
}

Kotlin では、配列は不変(invariant)です。これは、Array<String> が Array<Any> のサブタイプではないことを意味します。 これにより、実行時における型の不整合によるエラーの可能性が防止されます。共変性(covariance)を表現するには、Array<out Any> の 型射影(type projection)を使用します:

kotlin
fun main() {
    fun printArr(arr: Array<out Any>) {
        for (item in arr) print("$item, ")
    }

    printArr(arrayOf("k", "t", "n"))  
    // k, t, n, 
}

要素の追加と削除 ​

配列はサイズが固定されているため、.add() や .remove() 関数をサポートしていません。これらの操作を行うには、 新しい配列を作成する必要があります。そのためには、以下のいずれかの方法を使用できます:

  • .copyOf 関数を使用する:

    kotlin
    fun main() {
        var arr = intArrayOf(0, 1, 2)
        
        arr = arr.copyOf(arr.size + 1)
        println(arr.joinToString())
        // 0, 1, 2, 0
    
        arr[arr.lastIndex] = 3
        println(arr.joinToString())
        // 0, 1, 2, 3
    }
  • + または += 演算子を使用する:

    kotlin
    fun main() {
        var arr = intArrayOf(0, 1, 2)
    
        arr += 3
        println(arr.joinToString())
        // 0, 1, 2, 3
    
        arr = arr + intArrayOf(4, 5)
        println(arr.joinToString())
        // 0, 1, 2, 3, 4, 5
    }

要素を頻繁に追加または削除する必要がある場合は、 代わりに可変コレクションを使用してください。

配列の比較 ​

2つの配列が同じ順序で同じ要素を持っているかを比較するには、.contentEquals() および .contentDeepEquals() 関数を使用します:

kotlin
fun main() {
    val simpleArray = arrayOf(1, 2, 3)
    val anotherArray = arrayOf(1, 2, 3)

    // 配列の内容を比較
    println(simpleArray.contentEquals(anotherArray))
    // true

    // 中置記法を使用して、要素が変更された後の配列の内容を比較
    simpleArray[0] = 10
    println(simpleArray contentEquals anotherArray)
    // false
}

配列の内容を比較するために等価(==)および不等価(!=)演算子を使用しないでください。これらの演算子は、代入された変数が同じオブジェクトを指しているかどうかをチェックします。

Kotlin の配列がこのように動作する理由の詳細については、JetBrains のブログ投稿を参照してください。

配列の変換 ​

Kotlin には、配列を変換するための便利な関数が多数用意されています。このセクションでは、その一部を紹介します。 完全なリストについては、API リファレンスを参照してください。

合計 ​

配列内のすべての要素の合計を返すには、.sum() 関数を使用します:

kotlin
fun main() {
    val sumArray = arrayOf(1, 2, 3)
    println(sumArray.sum())
    // 6
}

.sum() 関数は、Int などの数値データ型の配列でのみ使用できます。

ソートとシャッフル ​

.sort() 関数を使用して配列の要素を自然順序に従ってソートしたり、 .shuffle() 関数を使用してランダムにシャッフルしたりできます:

kotlin
fun main() {
    val simpleArray = arrayOf(1, 2, 3)

    // 要素をランダムにシャッフル
    simpleArray.shuffle()
    println(simpleArray.joinToString())
  
    // 要素をソート
    simpleArray.sort()
    println(simpleArray.joinToString())
    // 1, 2, 3
}

元の配列を変更せずに新しいソート済み配列を取得するには、代わりに .sortedArray() 関数を使用してください。

関数への可変長引数の受け渡し ​

Kotlin では、vararg パラメータを介して関数に可変数の引数(可変長引数)を渡すことができます。これは、メッセージのフォーマットや SQL クエリの作成など、引数の数が事前にわからない場合に役立ちます。

可変数の引数を含む配列を関数に渡すには、スプレッド演算子(spread operator) (*)を使用します。スプレッド演算子は、配列の各要素を個別の引数として目的の関数に渡します:

kotlin
fun main() {
    val lettersArray = arrayOf("c", "d")
    printAllStrings("a", "b", *lettersArray)
    // abcd
}

fun printAllStrings(vararg strings: String) {
    for (string in strings) {
        print(string)
    }
}

詳細については、可変長の引数 (varargs) を参照してください。

コレクションへの変換 ​

配列を使用する API とコレクションを使用する API の両方を扱う場合、配列をコレクションに変換したり、 その逆を行ったりすることができます。そのためには、.toList()、.toSet()、および .toMap() 関数を使用します。 これらの関数は、配列の内容を独立したコピーへと複製します。その後の配列に対する変更は反映されません。

List または Set への変換 ​

配列を List または Set に変換するには、.toList() および .toSet() 関数を使用します:

kotlin
fun main() {
    val simpleArray = arrayOf("a", "b", "c", "c")

    // Set に変換
    println(simpleArray.toSet())
    // [a, b, c]

    // List に変換
    println(simpleArray.toList())
    // [a, b, c, c]
}

元の配列が変更されない、または他の場所で共有されていないことが完全に確実である場合を除き、 .asList() および関連する as* 関数は使用しないでください。これらの関数は配列をコピーするのではなく、元の配列をラップします。そのため、 配列への変更はリストに反映され、その逆も同様です。

kotlin
fun main() {
    val simpleArray = arrayOf("a", "b", "c")

    val list = simpleArray.asList()
    simpleArray[0] = "d"
    println(list)
    // [d, b, c]
}

Map への変換 ​

配列を Map に変換するには、.toMap() 関数を使用します。

Map に変換できるのは、Pair<K,V> の配列のみです。 Pair インスタンスの最初の値がキーになり、2番目の値が値になります。 同じキーが複数回出現する場合、最後の値が使用されます。

この例では、中置記法(infix notation)を使用して .to 関数を呼び出し、Pair のタプルを作成しています:

kotlin
fun main() {
    val pairArray = arrayOf("apple" to 120, "banana" to 150, "cherry" to 90, "apple" to 140)

    // Map に変換
    // フルーツがキー、カロリー数が値
    // 最新の "apple" の値が最初の値を上書きする
    println(pairArray.toMap())
    // {apple=140, banana=150, cherry=90}
}

次のステップ ​