Skip to content

陣列 ​

陣列是一種資料結構,用於容納固定數量的相同型別或其子型別的值。 陣列元素是有序的,並可透過索引進行存取。

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() {
    // 建立二維陣列
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }
    println(twoDArray.contentDeepToString())
    // [[0, 0], [0, 0]]

    // 建立三維陣列
    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() {
        // 建立大小為 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 為包含,而 toIndex 為不包含:

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> 的子型別。這可以防止可能發生的執行階段型別錯誤。若要表示協變性,請使用 Array<out Any> 型別投影:

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
    }

如果你需要頻繁新增或移除元素, 請改用可變集合。

比較陣列 ​

若要比較兩個陣列是否以相同順序包含相同的元素,請使用 .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 中的陣列為何具有這種行為,請參閱我們的部落格文章。

轉換陣列 ​

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 查詢時。

若要將包含可變數量引數的陣列傳遞給函式,請使用展開運算子(*)。展開運算子會將陣列中的每個元素作為單獨的引數傳遞給你所選擇的函式:

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 時,其中某些使用陣列而某些使用集合,則可以將陣列轉換為集合, 反之亦然。為此,請使用 .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() 函式。

你只能將包含 Pair<K,V> 的陣列轉換為 Map。 Pair 執行個體的第一個值將成為鍵,第二個值成為數值。 如果相同的鍵出現多次,則會使用最後一個值。

此範例使用中綴表示法 來呼叫 .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}
}

下一步? ​