91n资源在线,五十路一区

數(shù)組和集合

Kotlin為數(shù)組增加了一個(gè)Array類，因此可以用面向?qū)ο蟮恼Z(yǔ)法使用數(shù)組。

Kotlin自己提供一套集合體系，Kotlin的集合體系拋棄了Java集合體系中的Queue集合，但增加了可變集合和不可變集合。

與Java集合類似的是，依然存在List、Set、Map三種集合類型。

1. 數(shù)組

創(chuàng)建數(shù)組

使用arrayOf()工具函數(shù)。
使用arrayOfNulls()工具函數(shù)。
使用emptyArray()工具函數(shù)。
使用Array(size: Int, init: (Int) -> T)構(gòu)造器。
對(duì)于基本數(shù)據(jù)類型，可以使用類似intArrayOf()工具函數(shù)。

fun main(args: Array<String>) {

    // 創(chuàng)建指定元素的數(shù)組
    val arr1 = arrayOf("Java", "Kotlin", "Swift", "Go")

    // 創(chuàng)建指定長(zhǎng)度，元素為null的數(shù)組
    val arr2 = arrayOfNulls<Double>(4)

    // 創(chuàng)建長(zhǎng)度為0的空數(shù)組
    val arr3 = emptyArray<String>()

    // 創(chuàng)建指定長(zhǎng)度，使用Lambda表達(dá)式初始化數(shù)組元素的數(shù)組
    // val arr4 = Array(5, { (it * 2 + 97).toChar() })

    // 上面提示Lambda argument should be moved out of parentheses
    // 建議把Lambda從括號(hào)中提出來(lái)
    val arr4 = Array(5) { (it * 2 + 97).toChar() }
    val strArr4 = Array(3) { "JamFF" }

    // 下面兩種定義數(shù)組的類型是不一樣的
    val arr5: IntArray = intArrayOf(1, 2, 3)// 在JVM上是int，避免拆裝箱
    val arr6: Array<Int> = arrayOf(1, 2, 3)// 在JVM上是Integer
}

其中Array<T>類要求它的元素必須是引用類型，因此如果將基本類型存入，Kotlin會(huì)自動(dòng)裝箱為包裝類的實(shí)例，因此Kotlin提供了ByteArray、ShortArray、IntArray等8種基本數(shù)據(jù)類型的數(shù)組。

fun main(args: Array<String>) {
    // 基本數(shù)據(jù)類型的數(shù)組
    val arr1 = Array(5) { it * it }
    // 基本數(shù)據(jù)類型的數(shù)組
    val arr2 = IntArray(5) { it * it }
}

獲取和修改數(shù)組元素

fun main(args: Array<String>) {

    val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")

    // 兩種獲取數(shù)組元素的方式
    println(strArr.get(1))
    println(strArr[1]) // 推薦

    // 兩種方式修改數(shù)組元素
    strArr.set(2, "C")
    strArr[3] = "C++" // 推薦
    println(java.util.Arrays.toString(strArr))
}

使用for-in遍歷數(shù)組
注意：使用for-in遍歷時(shí)，不與許對(duì)循環(huán)變量賦值。

fun main(args: Array<String>) {

    val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")

    for (str in strArr) {
        println(str)
        // str = "C"http:// 遍歷時(shí)，不允許對(duì)循環(huán)變量賦值
    }
}

使用數(shù)組索引

使用數(shù)組size屬性，創(chuàng)建區(qū)間，遍歷索引

fun main(args: Array<String>) {

    val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")

    for (i in 0 until strArr.size) {
        println(strArr[i])
        strArr[i] = "C"http:// 這里可以對(duì)數(shù)組賦值，但是依然不能對(duì)循環(huán)變量i賦值
    }
}

使用數(shù)組lastIndex屬性，創(chuàng)建區(qū)間，遍歷索引

fun main(args: Array<String>) {

    val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")

    for (i in 0..strArr.lastIndex) {
        println(strArr[i])
    }
}

使用數(shù)組indices屬性，不需要額外創(chuàng)建區(qū)間對(duì)象，性能最好

fun main(args: Array<String>) {

    val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")

    for (i in strArr.indices) {
        println(strArr[i])
    }
}

同時(shí)訪問(wèn)數(shù)組的索引和元素

fun main(args: Array<String>) {

    val strArr = arrayOf("Java", "Kotlin", "Swift", "Go")

    for ((index, value) in strArr.withIndex()) {
        println("索引為${index}的元素是：$value")
    }
}

數(shù)組的常用方法

fun main(args: Array<String>) {

    val arr = arrayOf(2, 4, 5, 6)

    // 判斷是否所有元素的平方都大于20
    println(arr.all { it * it > 20 }) // false
    // 判斷是否由一個(gè)元素的平方大于20
    println(arr.any { it * it > 20 }) // false

    val a1 = arrayOf(3, 4, 5, 6)
    val a2 = arrayOf(3, 4, 5, 6)

    // 判斷數(shù)組內(nèi)每個(gè)元素是否相等
    println("a1和a2數(shù)組是否相等：${a1.contentEquals(a2)}")

    // 復(fù)制數(shù)組
    val b = a1.copyOf(6)
    // 打印數(shù)組元素
    println(b.contentToString()) // [3, 4, 5, 6, null, null]

    // 將b數(shù)組的索引為4（包含）到6（不包含）的元素賦值為1
    b.fill(1, 4, 6)
    println(b.contentToString()) // [3, 4, 5, 6, 1, 1]

    // 排序
    b.sort()
    println(b.contentToString()) // [1, 1, 3, 4, 5, 6]
    
    // 由于數(shù)組提供了operator修飾的plus()，所以可以使用+
    println((c + d).contentToString())
    // 由于數(shù)組提供了operator修飾的contains()，所以可以使用in
    println("Java" in c)
}

2. 集合概述

Kotlin的集合類同樣是由連個(gè)接口派生：Collection和Map，但是區(qū)別是Kotlin集合分為可變集合和不可變集合，可變集合是不可變集合的子類。

Kotlin只提供HashSet、HashMap、LinkedHashSet、LinkedHashMap、ArrayList這5個(gè)集合實(shí)現(xiàn)類，并且他們都是不可變集合；有Mutable前綴的都是可變集合；不可變集合可以通過(guò)toMutable*()函數(shù)轉(zhuǎn)換成可變集合。

3. Set集合

聲明和創(chuàng)建Set集合

setOf()：不可變的Set集合。
mutableSetOf()：可變的Set集合。
hashSetOf()：可變的HashSet集合。
linkedSetOf()：可變的LinkedHashSet集合。
sortedSetOf()：可變的TreeSet集合。

fun main(args: Array<String>) {

    // 不可變的Set集合，在目前Kotlin1.2中返回的是LinkedHashSet，元素的添加順序
    val set = setOf("Java", "Kotlin", "Go")
    // 可變的Set集合，在目前Kotlin1.2中返回的是LinkedHashSet，元素的添加順序
    val mutableSet = mutableSetOf("Java", "Kotlin", "Go")
    // 可變的HashSet集合，不保證元素的順序
    val hashSet = hashSetOf("Java", "Kotlin", "Go")
    // 可變的LinkedHashSet集合，元素的添加順序
    val linkedHashSet = linkedSetOf("Java", "Kotlin", "Go")
    // 可變的TreeSet集合，元素由小到大排序
    val treeSet = sortedSetOf("Java", "Kotlin", "Go")
}

Set的常用方法

fun main(args: Array<String>) {

    // 不可變的Set集合，在目前Kotlin1.2中返回的是LinkedHashSet，元素的添加順序
    val set = setOf("Java", "Kotlin", "Go")

    // 判讀是否所有元素的長(zhǎng)度都大于4
    println(set.all { it.length > 4 }) // false

    // 判斷是否存在一個(gè)元素長(zhǎng)度大于四
    println(set.any { it.length > 4 }) // true

    // 存在contains()所以可以使用in、!in運(yùn)算符
    println("Java" in set) // true

    // 返回刪除前面兩個(gè)元素的集合
    println(set.drop(2)) // [Go]

    // 過(guò)濾集合元素，要求集合元素包含"li"，如果不存在則返回size為0的集合
    println(set.filter { "li" in it }) // [Kotlin]

    // 查找包含"li"的元素，存在就返回該元素，否則返回null
    println(set.find { "li" in it }) // Kotlin
    println(set.find { "JamFF" in it }) // null

    // 查找某個(gè)元素出現(xiàn)的索引位置
    println(set.indexOf("Go")) // 2

    // 將集合每個(gè)元素映射為新值，返回所有新值組成的Set集合
    println(set.map { "學(xué)習(xí)$it" }) // [學(xué)習(xí)Java, 學(xué)習(xí)Kotlin, 學(xué)習(xí)Go]

    // 獲取最大、最小元素
    println(set.max()) // Kotlin
    println(set.min()) // Go

    // 反轉(zhuǎn)集合順序
    println(set.reversed()) // [Go, Kotlin, Java]

    val bSet = setOf("C", "Python", "Kotlin")

    // 計(jì)算兩個(gè)集合的交集
    println(set intersect bSet) // [Kotlin]
    // 計(jì)算兩個(gè)集合的并集
    println(set union bSet) // [Java, Kotlin, Go, C, Python]
    // 集合相加，相當(dāng)于并集
    println(set + bSet) // [Java, Kotlin, Go, C, Python]
    // 集合相減，減去他們公共的元素
    println(set - bSet)// [Java, Go]
}

遍歷Set

for-in遍歷
forEach()遍歷
setOf()是有序的，可以通過(guò)索引遍歷

fun main(args: Array<String>) {

    val set = setOf("Java", "Kotlin", "Go")
    // for-in遍歷
    for (str in set) {
        println(str)
    }
    // forEach()遍歷
    set.forEach { println(it) }
    // setOf()是有序的，可以通過(guò)索引遍歷
    for (i in set.indices) {
        println(set.elementAt(i))
    }
}

可變的Set

添加元素

fun main(args: Array<String>) {

    val set = mutableSetOf("Swift")

    set.add("Go")
    set.addAll(setOf("Java", "Kotlin"))

    println(set) // [Swift, Go, Java, Kotlin]
}

刪除元素

fun main(args: Array<String>) {

    val set = mutableSetOf("Kotlin", "OC", "PHP", "Perl", "Ruby", "Go")

    set.remove("PHP")
    set.removeAll(setOf("Ruby", "GO"))

    // 保留兩個(gè)集合共有的元素
    set.retainAll(setOf("Kotlin", "Python", "C++", "Perl"))
    println(set) // [Kotlin, Perl]

    set.clear()
    println(set.count()) // 0
}

4. List集合

聲明和創(chuàng)建List集合

listOf()：不可變的List集合。
listOfNotNull()：不可變的List集合，會(huì)去掉參數(shù)中的null值。
mutableListOf()：可變的MutableList集合。
arrayListOf()：可變的ArrayList集合。

fun main(args: Array<String>) {

    // [Kotlin, null, PHP, Go]
    println(listOf("Kotlin", null, "PHP", "Go"))

    // [Kotlin, PHP, Go]
    println(listOfNotNull("Kotlin", null, "PHP", "Go"))

    val mutableList = mutableListOf("Kotlin", null, "PHP", "Go");
    println(mutableList) // [Kotlin, null, PHP, Go]
    // mutableListOf在Kotlin1.2中，返回的其實(shí)也是ArrayList
    println(mutableList.javaClass) // class java.util.ArrayList

    // [Kotlin, null, PHP, Go]
    println(arrayListOf("Kotlin", null, "PHP", "Go"))
}

List的常用方法

Set支持的操作，List一般都能支持，還增加里索引操作集合元素的方法。

fun main(args: Array<String>) {

    val list = listOf("Kotlin", "Java", "PHP", "Go")

    for (i in list.indices) {
        println(list[i])
    }

    println(list.indexOf("Java")) // 1
    // 獲取List的子集，包左不包右
    println(list.subList(1, 3)) // [Java, PHP]
}

可變的List

Set支持的操作，List一般都能支持，還增加里索引操作集合元素的方法。

fun main(args: Array<String>) {

    val list = mutableListOf("Kotlin", null, "Go")

    list.add(2, "Java")

    list.removeAt(1)

    list[1] = "Python"

    list.clear()
}

5. Map集合

聲明和創(chuàng)建Map集合

mapOf()：不可變的Map集合。
mutableMapOf()：可變的MutableMap集合。
hashMapOf()：可變的HashMap集合。
linkedMapOf()：可變的LinkedHashMap集合。
sortedMapOf()：可變的TreeMap集合。

fun main(args: Array<String>) {

    val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
    val mutableMap = mutableMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
    val hashMap = hashMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
    val linkedHashMap = linkedMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
    val treeMap = sortedMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
}

Map常用的方法

fun main(args: Array<String>) {

    val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)

    println(map.all { it.key.length > 4 && it.value > 80 }) // false
    println(map.any { it.key.length > 4 && it.value > 80 }) // true

    println("Java" in map) // true
    println(map.filter { "li" in it.key }) // {Kotlin=92}
    println(map.maxBy { it.key }) // Kotlin=92
    println(map.minBy { it.value }) // Go=78

    val mapB = mapOf("Lua" to 67, "Kotlin" to 92, "PHP" to 73)
    println(map + mapB) // {Java=86, Kotlin=92, Go=78, Lua=67, PHP=73}
    println(map - map) // {Java=86, Kotlin=92, Go=78}
}

最后的相減沒(méi)有搞明白，認(rèn)為應(yīng)該輸出{Java=86, Go=78}，哪怕是寫(xiě)成map - map，輸出結(jié)果還是{Java=86, Kotlin=92, Go=78}，希望大神賜教。

遍歷Map

四種常用的遍歷方式

fun main(args: Array<String>) {

    val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)

    for (en in map.entries) {
        println("${en.key}->${en.value}")
    }

    for (key in map.keys) {
        println("$key->${map[key]}")
    }

    for ((key, value) in map) {
        println("$key->$value")
    }

    map.forEach { println("${it.key}->${it.value}") }
}

可變的Map

fun main(args: Array<String>) {

    val map = mutableMapOf("OC" to 96, "PHP" to 3400,
            "Ruby" to 5600, "Go" to 5600)

    map["Swift"] = 9000
    map.put("OC", 8600)// 和上面[]效果一致

    map.remove("PHP")

    map.putAll(mapOf("Java" to 84, "Python" to 67))

    map.clear()
}

重點(diǎn)

數(shù)組
Set、List、Map三種集合的使用
Kotlin區(qū)別Java存在不可變集合
Kotlin的集合類較Java有更多的API

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Kotlin快速入門(mén)（四）——數(shù)組與集合

Kotlin快速入門(mén)（四）——數(shù)組與集合

數(shù)組和集合

1. 數(shù)組

2. 集合概述

3. Set集合

4. List集合

5. Map集合

重點(diǎn)

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Kotlin快速入門(mén)（四）——數(shù)組與集合

數(shù)組和集合

1. 數(shù)組

2. 集合概述

3. Set集合

4. List集合

5. Map集合

重點(diǎn)

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av