前序

??????Kotlin沒有自己的集合庫(kù)，完全依賴Java標(biāo)準(zhǔn)庫(kù)中的集合類，并通過擴(kuò)展函數(shù)增加特性來增強(qiáng)集合。意味著Kotlin與Java交互時(shí)，永遠(yuǎn)不需要包裝或者轉(zhuǎn)換這些集合對(duì)象，大大增強(qiáng)與Java的互操作性。

只讀集合和可變集合

??????Kotlin與Java最大的不同之一就是：Kotlin將集合分為只讀集合和可變集合。這種區(qū)別源自最基礎(chǔ)的集合接口：kotlin.collections.Collection。該接口可以對(duì)集合進(jìn)行一些基本操作，但無(wú)任何添加和移除元素的方法。

??????只有實(shí)現(xiàn) kotlin.collections.MutableCollection 接口才可以修改集合的數(shù)據(jù)。MutableCollection 接口繼承自 Collection，并提供添加、移除和清空集合元素的方法。當(dāng)一個(gè)函數(shù)接收 Collection，而不是 MutableCollection，即意味著函數(shù)不對(duì)集合做修改操作。

image

image

創(chuàng)建集合

??????Kotlin中創(chuàng)建集合一般都是通過 Collection.kt 中的頂層函數(shù)進(jìn)行創(chuàng)建。具體方法如下：

??????像 arrayListOf 這些指明集合類型的頂層函數(shù)，創(chuàng)建時(shí)都是對(duì)應(yīng)著Java相應(yīng)類型的集合。為了弄清楚 Kotlin 的生成的只讀集合（listOf、setOf 和 mapOf）與可變集合（mutableList、mutableSetOf 和 mutableMapOf）生成的是什么Java類型集合，做了一個(gè)小實(shí)驗(yàn)（分別對(duì)應(yīng)空集合、單元素集合和多元素集合）：

• 1、使用在Java類中編寫一些打印集合類型的靜態(tài)方法：

#daqiJava.java
public static void collectionsType(Collection collection){
    System.out.println(collection.getClass().getName());
}

public static void mapType(Map map){
    System.out.println(map.getClass().getName());
}

• 2、在Kotlin中創(chuàng)建只讀集合和可變集合，并將其傳入之前聲明的Java靜態(tài)方法中進(jìn)行打印：

#daqiKotlin.kt
fun main(args: Array<String>) {
    val emptyList = listOf<Int>()
    val emptySet = setOf<Int>()
    val emptyMap = mapOf<Int,Int>()
    
    val initList = listOf(1)
    val initSet = setOf(2)
    val initMap = mapOf(1 to 1)
    
    val list = listOf(1,2)
    val set = setOf(1,2)
    val map = mapOf(1 to 1,2 to 2)

    println("空元素只讀集合")
    collectionsType(emptyList)
    collectionsType(emptySet)
    mapType(emptyMap)
    
    println("單元素只讀集合")
    collectionsType(initList)
    collectionsType(initSet)
    mapType(initMap)
    
    println("多元素只讀集合")
    collectionsType(list)
    collectionsType(set)
    mapType(map)

    println("-----------------------------------------------------------------")

    val emptyMutableList = mutableListOf<Int>()
    val emptyMutableSet = mutableSetOf<Int>()
    val emptyMutableMap = mutableMapOf<Int,Int>()

    val initMutableList = mutableListOf(1)
    val initMutableSet = mutableSetOf(2)
    val initMutableMap = mutableMapOf(1 to 1)


    val mutableList = mutableListOf(1,2)
    val mutableSet = mutableSetOf(1,2)
    val mutableMap = mutableMapOf(1 to 1,2 to 2)

    println("空元素可變集合")
    collectionsType(emptyMutableList)
    collectionsType(emptyMutableSet)
    mapType(emptyMutableMap)

    println("單元素可變集合")
    collectionsType(initMutableList)
    collectionsType(initMutableSet)
    mapType(initMutableMap)

    println("多元素可變集合")
    collectionsType(mutableList)
    collectionsType(mutableSet)
    mapType(mutableMap)
}

結(jié)果：

image

型變

??????只讀集合類型是型變的。當(dāng)類 Rectangle 繼承自 Shape，則可以在需要 List<Shape> 的任何地方使用 List<Rectangle>。 因?yàn)榧项愋团c元素類型具有相同的子類型關(guān)系。 Map在值類型上是型變的，但在鍵類型上不是。

??????可變集合不是型變的。 MutableList <Rectangle> 是 MutableList <Shape> 的子類型，當(dāng)你插入其他 Shape 的繼承者（例如，Circle），從而違反了它的 Rectangle 類型參數(shù)。

集合的可空性

??????對(duì)于任何類型，都可以對(duì)其聲明為可空類型，集合也不例外。你可以將集合元素的類型設(shè)置為可空，也可以將集合本身設(shè)置為可空，需要清楚是集合的元素可空還是集合本身可空。

image

Kotlin集合的秘密：平臺(tái)相關(guān)聲明

尋找java.util.ArrayList<E>

??????學(xué)習(xí) Kotlin 的時(shí)候，常常被告知 Kotlin 直接使用的是原生 Java 集合，抱著探究真相的心態(tài)，點(diǎn)進(jìn)了創(chuàng)建集合的頂層方法 mutableListOf() 。

#Collections.kt
public fun <T> mutableListOf(vararg elements: T): MutableList<T> =
    if (elements.size == 0) 
        ArrayList() 
    else
        ArrayList(ArrayAsCollection(elements, isVarargs = true))

??????在源碼中看到了熟悉的ArrayList，那是Java的ArrayList嘛？繼續(xù)點(diǎn)進(jìn)ArrayList，發(fā)現(xiàn)是一個(gè)Kotlin定義的ArrayList：

#ArrayList.kt
expect class ArrayList<E> : MutableList<E>, RandomAccess {
    constructor()
    constructor(initialCapacity: Int)
    constructor(elements: Collection<E>)
    
    //... 省略一些來自List、MutableCollection和MutableList的方法
    //這些方法只有聲明，沒有具體實(shí)現(xiàn)。
}

??????逛了一大圈，并沒有找到一絲 Java 的 ArrayList 的痕跡.... Excuse me??? 說好的使用 Java 的 ArrayList ,但自己又創(chuàng)建了一個(gè)ArrayList.... 。最后將目標(biāo)鎖定在類聲明的 expect 關(guān)鍵字，這是什么？最后在Kotlin官網(wǎng)中查到，這是Kotlin 平臺(tái)相關(guān)聲明的預(yù)期聲明！

平臺(tái)相關(guān)聲明

??????在其他語(yǔ)言中，通常在公共代碼中構(gòu)建一組接口,并在平臺(tái)相關(guān)模塊中實(shí)現(xiàn)這些接口來實(shí)現(xiàn)多平臺(tái)。然而，當(dāng)在其中某個(gè)平臺(tái)上已有一個(gè)實(shí)現(xiàn)所需功能的庫(kù)，并且希望直接使用該庫(kù)的API而無(wú)需額外包裝器時(shí)，這種方法并不理想。

??????Kotlin 提供平臺(tái)相關(guān)聲明機(jī)制。 利用這種機(jī)制，公共模塊中定義預(yù)期聲明，而平臺(tái)模塊提供與預(yù)期聲明相對(duì)應(yīng)的實(shí)際聲明。

要點(diǎn)：

• 公共模塊中的預(yù)期聲明與其對(duì)應(yīng)的實(shí)際聲明始終具有完全相同的完整限定名。
• 預(yù)期聲明標(biāo)有 expect 關(guān)鍵字；實(shí)際聲明標(biāo)有 actual 關(guān)鍵字。
• 與預(yù)期聲明的任何部分匹配的所有實(shí)際聲明都需要標(biāo)記為 actual。
• 預(yù)期聲明 決不包含任何實(shí)現(xiàn)代碼。

官網(wǎng)提供一個(gè)簡(jiǎn)單的例子：

#kt
//在公共模塊中定義一個(gè)預(yù)期聲明（不帶任何實(shí)現(xiàn)）
expect class Foo(bar: String) {
    fun frob()
}

fun main() {
    Foo("Hello").frob()
}

相應(yīng)的 JVM 模塊提供實(shí)現(xiàn)聲明和相應(yīng)的實(shí)現(xiàn)：

#kt
//提供實(shí)際聲明
actual class Foo actual constructor(val bar: String) {
    actual fun frob() {
        println("Frobbing the $bar")
    }
}

??????如果有一個(gè)希望用在公共代碼中的平臺(tái)相關(guān)的庫(kù)，同時(shí)為其他平臺(tái)提供自己的實(shí)現(xiàn)。（像Java已提供好完整的集合庫(kù)）那么可以將現(xiàn)有類的別名作為實(shí)際聲明：

expect class AtomicRef<V>(value: V) {
  fun get(): V
  fun set(value: V)
  fun getAndSet(value: V): V
  fun compareAndSet(expect: V, update: V): Boolean
}

actual typealias AtomicRef<V> = java.util.concurrent.atomic.AtomicReference<V>

??????而Java集合類作為實(shí)際聲明的別名被定義在 TypeAliases.kt 中。這是我不知道 TypeAliases.kt 時(shí)的查找流程：

image

# TypeAliases.kt
@SinceKotlin("1.1") public actual typealias RandomAccess = java.util.RandomAccess

@SinceKotlin("1.1") public actual typealias ArrayList<E> = java.util.ArrayList<E>
@SinceKotlin("1.1") public actual typealias LinkedHashMap<K, V> = java.util.LinkedHashMap<K, V>
@SinceKotlin("1.1") public actual typealias HashMap<K, V> = java.util.HashMap<K, V>
@SinceKotlin("1.1") public actual typealias LinkedHashSet<E> = java.util.LinkedHashSet<E>
@SinceKotlin("1.1") public actual typealias HashSet<E> = java.util.HashSet<E>

??????Kotlin定義一些集合類作為集合的通用層（使用 expect 定義預(yù)期聲明），并將現(xiàn)有的Java集合類的別名作為實(shí)際聲明，從而實(shí)現(xiàn)在JVM上直接使用Java的集合類。

ArrayList的變遷

可以從Kotlin官方文檔中集合的變遷來觀察（ArrayList為例）:

• 1.0版本ArrayList：

  
  
  image

• 1.1版本ArrayList：

  
  
  image

• 1.3版本ArrayList：

  
  
  image

??????從原本無(wú)ArrayList.kt,只有一系列對(duì)ArrayList.java的擴(kuò)展屬性與方法

-> 使用別名引用Java的ArrayList.java，ArrayList.kt服務(wù)于Js模塊。

-> 使用平臺(tái)相關(guān)聲明，將ArrayList.kt作為預(yù)期聲明，并在JVM模塊、Js模塊、Native模塊中提供具體的實(shí)際聲明。使Kotlin對(duì)外提供"通用層"API，在不改變代碼的情況下,實(shí)現(xiàn)跨平臺(tái)。

只讀集合與平臺(tái)相關(guān)聲明

??????當(dāng)對(duì)應(yīng)單個(gè)或多個(gè)初始化值的集合時(shí)，其使用的都是Java的集合類型，一起探究下是否也與平臺(tái)相關(guān)聲明有關(guān)：

單元素只讀集合

??????創(chuàng)建單元素集合的listOf(element: T)、setOf(element: T)和mapOf(pair: Pair<K, V>)直接作為頂層函數(shù)聲明在JVM模塊中，并直接使用Java的單元素集合類進(jìn)行初始化。

#CollectionsJVM.kt
//listOf
public fun <T> listOf(element: T): List<T> =
java.util.Collections.singletonList(element)

#SetsJVM.kt
//setOf
public fun <T> setOf(element: T): Set<T> =
java.util.Collections.singleton(element)

#MapsJVM.kt
//mapOf
public fun <K, V> mapOf(pair: Pair<K, V>): Map<K, V> =
java.util.Collections.singletonMap(pair.first, pair.second)

多元素只讀集合

??????創(chuàng)建多元素集合的頂層函數(shù)的參數(shù)都帶有vararg聲明，這類似于Java的可變參數(shù)，接收任意個(gè)數(shù)的參數(shù)值，并打包為數(shù)組。

• listOf(vararg elements: T)：

#Collections.kt
public fun <T> listOf(vararg elements: T): List<T> = 
if (elements.size > 0) elements.asList() else emptyList()

listOf(vararg elements: T)函數(shù)會(huì)直接將可變參數(shù)轉(zhuǎn)換為list:

#_Arrays.kt
public expect fun <T> Array<out T>.asList(): List<T>

Array.asList()擁有 expect 關(guān)鍵字，即作為預(yù)期聲明存在,這意味著JVM模塊會(huì)提供對(duì)應(yīng)的實(shí)現(xiàn)：

#_ArraysJvm.kt
public actual fun <T> Array<out T>.asList(): List<T> {
    return ArraysUtilJVM.asList(this)
}

#ArraysUtilJVM.java
class ArraysUtilJVM {
    static <T> List<T> asList(T[] array) {
        return Arrays.asList(array);
    }
}

在JVM模塊中提供了實(shí)際聲明的Array.asList()，并調(diào)用了java.util.Arrays.asList(),返回java.util.Arrays的靜態(tài)內(nèi)部類java.util.Arrays$ArrayList對(duì)象。

• setOf(vararg elements: T):

#Sets.kt
public fun <T> setOf(vararg elements: T): Set<T> = 
if (elements.size > 0) elements.toSet() else emptySet()

setOf(vararg elements: T)函數(shù)會(huì)直接將可變參數(shù)轉(zhuǎn)換為set:

public fun <T> Array<out T>.toSet(): Set<T> {
    return when (size) {
        0 -> emptySet()
        1 -> setOf(this[0])
        else -> toCollection(LinkedHashSet<T>(mapCapacity(size)))
    }
}

并和mutableSetOf()一樣，使用Kotlin的LinkedHashSet依托平臺(tái)相關(guān)聲明創(chuàng)建java.util.LinkedHashSet對(duì)象。(具體轉(zhuǎn)換邏輯不深究)

• mapOf(vararg pairs: Pair<K, V>)

public fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V> =
    if (pairs.size > 0) pairs.toMap(LinkedHashMap(mapCapacity(pairs.size))) else emptyMap()

并和mutableMapOf()一樣，使用Kotlin的LinkedHashMap依托平臺(tái)相關(guān)聲明創(chuàng)建java.util.LinkedHashMap對(duì)象。(具體轉(zhuǎn)換邏輯不深究)

集合的函數(shù)式API

??????了解了一波Kotlin的集合后，需要回歸到對(duì)集合的使用上——集合的函數(shù)式API。

filter函數(shù)

基本定義：

??????filter函數(shù)遍歷集合并返回給定lambda中返回true的元素。

源碼：

#_Collection.kt
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    //創(chuàng)建一個(gè)新的集合并連同lambda一起傳遞給filterTo()
    return filterTo(ArrayList<T>(), predicate)
}

public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C {
    //遍歷原集合
    for (element in this) 
        //執(zhí)行l(wèi)ambda，如返回為true,則將該元素添加到新集合中
        if (predicate(element)) 
            destination.add(element)
    //返回新集合
    return destination
}

解析:

??????創(chuàng)建一個(gè)新的ArrayList對(duì)象，遍歷原集合，將lambda表達(dá)式返回true的元素添加到新ArrayList對(duì)象中，最后返回新的ArrayList對(duì)象。

image

map函數(shù)

基本定義：

??????map函數(shù)對(duì)集合中每一個(gè)元素應(yīng)用給定的函數(shù)，并把結(jié)果收集到一個(gè)新集合。

源碼:

#_Collection.kt
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
    //創(chuàng)建一個(gè)新的集合并連同lambda一起傳遞給mapTo()
    return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}

public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C {
    //遍歷舊集合元素
    for (item in this)
        //執(zhí)行l(wèi)ambda，對(duì)元素進(jìn)行處理，將返回值添加到新集合中
        destination.add(transform(item))
    //返回新集合
    return destination
}

解析:

??????創(chuàng)建一個(gè)新的ArrayList集合，遍歷原集合，將函數(shù)類型對(duì)象處理過的值添加到新ArrayList對(duì)象中，并返回新的ArrayList對(duì)象。

image

groupBy函數(shù)

基本定義：

??????對(duì)集合元素進(jìn)行分組,并返回一個(gè)Map集合,存儲(chǔ)元素分組依據(jù)的鍵和元素分組

源碼:

#_Collection.kt
public inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>> {
    //創(chuàng)建一個(gè)新的map并連同lambda一起傳遞給groupByTo()
    return groupByTo(LinkedHashMap<K, MutableList<T>>(), keySelector)
}

public inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K): M {
    //遍歷舊集合元素
    for (element in this) {
        //執(zhí)行l(wèi)ambda，對(duì)元素進(jìn)行處理，將返回值作為key
        val key = keySelector(element)
        //使用得到的key在新的map中獲取vlaue，如果沒有則創(chuàng)建一個(gè)ArrayList對(duì)象，作為value存儲(chǔ)到map中，并返回ArrayList對(duì)象。
        val list = destination.getOrPut(key) { ArrayList<T>() }
        //對(duì)ArrayList對(duì)象添加當(dāng)前元素
        list.add(element)
    }
    //返回新集合
    return destination
}

解析:

??????創(chuàng)建一個(gè)LinkedHashMap對(duì)象，遍歷舊集合的元素，將函數(shù)類型對(duì)象處理過的值作為key,對(duì)應(yīng)的元素存儲(chǔ)到一個(gè)ArrayList中，并將該ArrayList對(duì)象作為map的value進(jìn)行存儲(chǔ)。返回LinkedHashMap對(duì)象。

image

flatMap函數(shù)

基本定義：

??????根據(jù)實(shí)參給定的函數(shù)對(duì)集合中的每個(gè)元素做交換（映射），然后把多個(gè)列表平鋪成一個(gè)列表。

源碼:

#_Collection.kt
public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R> {
    //創(chuàng)建一個(gè)新的集合并連同lambda一起傳遞給flatMapTo()
    return flatMapTo(ArrayList<R>(), transform)
}

public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C {   
    ////遍歷舊集合元素
    for (element in this) {
        //執(zhí)行l(wèi)ambda，對(duì)元素進(jìn)行處理，返回一個(gè)集合
        val list = transform(element)
        //在得到的集合添加到新的集合中。
        destination.addAll(list)
    }
    //返回新集合
    return destination
}

解析:

??????創(chuàng)建一個(gè)新的ArrayList集合，遍歷原集合，對(duì)原集合的元素轉(zhuǎn)換成列表，最后將轉(zhuǎn)換得到的列表存儲(chǔ)到新的ArrayList集合中，并返回新的ArrayList對(duì)象。

image

all函數(shù) 和 any函數(shù)

基本定義：

??????檢查集合中的所有元素是否都符合或是否存在符合的元素。

源碼:

#_Collection.kt
//any
public inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean {
    //判斷他是否為空，如果集合為空集合，直接返回false，因?yàn)榭隙ú淮嬖?    if (this is Collection && isEmpty()) 
        return false
    for (element in this) 
        //遍歷元素的過程中，如果有其中一個(gè)元素滿足條件，則直接返回true
        if (predicate(element)) 
            return true
    //最后都不行，就返回false
    return false
}

//all
public inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean {
    //如果集合為空集合，直接返回true
    if (this is Collection && isEmpty()) 
        return true
    for (element in this) 
        //遍歷元素的過程中，只要有其中一個(gè)元素不滿足條件，則直接返回false
        if (!predicate(element)) 
            return false
    return true
}

count函數(shù)

基本定義：

??????檢查有多少滿足條件的元素?cái)?shù)量。

源碼:

#_Collection.kt
public inline fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int {
    if (this is Collection && isEmpty()) 
        return 0
    //弄一個(gè)臨時(shí)變量記錄數(shù)量
    var count = 0
    //遍歷元素
    for (element in this) 
        //如果滿足添加，則數(shù)量+1
        if (predicate(element)) 
            checkCountOverflow(++count)
    return count
}

find函數(shù)

基本定義：

??????尋找第一個(gè)符合條件的元素，如果沒有符合條件的元素，則返回null。

源碼:

#_Collection.kt
public inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T? {
    //將lambda傳給firstOrNull()
    return firstOrNull(predicate)
}

public inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T? {
    for (element in this) 
        //遍歷的元素中，返回第一個(gè)符合滿足添加的元素。
        if (predicate(element)) 
            return element
    //沒找到，則返回null
    return null
}

集合使用的注意事項(xiàng)

• 優(yōu)先使用只讀集合，只有在需要修改集合的情況下才使用可變集合。
• 只讀集合不一定是不可變的。如果你使用的變量是只讀接口的類型，該變量可能引用的是一個(gè)可變集合。因?yàn)橹蛔x接口Collection是所有集合的"基類"
• 只讀集合并不總是線程安全的。如果需要在多線程環(huán)境中處理數(shù)據(jù)，必須使用支持并發(fā)訪問的數(shù)據(jù)結(jié)構(gòu)。

數(shù)組

??????Kotlin數(shù)組是一個(gè)帶有類型參數(shù)的類，其元素類型被指定為相應(yīng)的類型參數(shù)。

在Kotlin中提供以下方法創(chuàng)建數(shù)組：

• arrayOf函數(shù)，該函數(shù)的實(shí)參作為數(shù)組的元素。
• arrayOfNulls函數(shù)，創(chuàng)建一個(gè)給定大小的數(shù)組，包含的是null值。一般用來創(chuàng)建元素類型可空的數(shù)組
• Array構(gòu)造方法，接收一個(gè)數(shù)組的大小和lambda表達(dá)式。lambda表達(dá)式用來創(chuàng)建每一個(gè)數(shù)組元素，不能顯式地傳遞每一個(gè)元素。

val array = Array<String>(5){
    it.toChar() + "a"
}

??????Kotlin最常見的創(chuàng)建數(shù)組的情況是：調(diào)用需要數(shù)組為參數(shù)的Java方法，或調(diào)用帶有vararg參數(shù)的Kotlin函數(shù)。這時(shí)需要使用toTypeArray()將集合轉(zhuǎn)換成數(shù)組。

val list = listOf("daqi","java","kotlin")
//集合轉(zhuǎn)數(shù)組
list.toTypedArray()

val array = arrayOf("")
//數(shù)組轉(zhuǎn)集合
array.toList()

??????Array類的類型參數(shù)決定了創(chuàng)建的是一個(gè)基本數(shù)據(jù)類型裝箱的數(shù)組。當(dāng)需要?jiǎng)?chuàng)建沒有裝箱的基本數(shù)據(jù)類型的數(shù)組時(shí)，必須使用基本數(shù)據(jù)類型數(shù)組。Kotlin為每一種基本數(shù)據(jù)類型提供獨(dú)立的基本數(shù)據(jù)類型數(shù)組。例如：Int類型的數(shù)組叫做IntArray?；緮?shù)據(jù)類型數(shù)組會(huì)被編譯成普通的Java基本數(shù)據(jù)類型的數(shù)組，如int[].因此基本數(shù)據(jù)類型數(shù)組在存儲(chǔ)值時(shí)并沒有裝箱。

創(chuàng)建基本數(shù)據(jù)類型數(shù)組：

• 工廠方法(例如intArrayOf)接收變長(zhǎng)參數(shù)并創(chuàng)建存儲(chǔ)這些值的數(shù)組。
• 基本數(shù)據(jù)類型數(shù)組的構(gòu)造方法。

??????Kotlin標(biāo)準(zhǔn)庫(kù)中對(duì)集合的支持?jǐn)U展庫(kù)（filter、map等）一樣適用于數(shù)組，包括基本數(shù)據(jù)類型的數(shù)組。

參考資料：

• 《Kotlin實(shí)戰(zhàn)》
• Kotlin官網(wǎng)

android Kotlin系列：

Kotlin知識(shí)歸納（一） —— 基礎(chǔ)語(yǔ)法

Kotlin知識(shí)歸納（二） —— 讓函數(shù)更好調(diào)用

Kotlin知識(shí)歸納（三） —— 頂層成員與擴(kuò)展

Kotlin知識(shí)歸納（四） —— 接口和類

Kotlin知識(shí)歸納（五） —— Lambda

Kotlin知識(shí)歸納（六） —— 類型系統(tǒng)

Kotlin知識(shí)歸納（七） —— 集合

Kotlin知識(shí)歸納（八） —— 序列

Kotlin知識(shí)歸納（九） —— 約定

Kotlin知識(shí)歸納（十） —— 委托

Kotlin知識(shí)歸納（十一） —— 高階函數(shù)

Kotlin知識(shí)歸納（十二） —— 泛型

Kotlin知識(shí)歸納（十三） —— 注解

Kotlin知識(shí)歸納（十四） —— 反射

image