kotlin集合——>集合概述、構造集合

1.kotlin集合概述

　　在kotli.collections包中包含List(有序集合)、Set(無序集合)、Map(健值對)三種集合

2.val定義的集合，調用集合方法可以添加刪除，但是如果重新創建對象，則報錯

val numbers = mutableListOf("one", "two", "three", "four")
numbers.add("five") // 這是可以的
//numbers = mutableListOf("six", "seven") // 編譯錯誤

3.Collection

　　Collection<T> 是集合層次結構的根。此接口表示一個只讀集合的共同行為:檢索大小、檢測是否為 成員等等。Collection 繼承自 Iterable <T> 接口，它定義了迭代元素的操作。可以使用Collection 作為適用於不同集合類型的函數的參數。對於更具體的情況，請使用 Collection 的 繼承者:List 與 Set。

fun printAll(strings: Collection<String>) {
    for (s in strings) print("$s ")
    println()
}

fun main() {
    val stringList = listOf("one", "two", "one")
    printAll (stringList)
    
    val stringSet = setOf("one", "two", "three")
    printAll(stringSet)
}

　　MutableCollection 是一個具有寫操作的 Collection 接口，例如 add 以及 remove 。

fun List<String>.getShortWordsTo(shortWords: MutableList<String>, maxLength: Int) {
    this.filterTo(shortWords) { it.length <= maxLength }
// throwing away the articles
    val articles = setOf("a", "A", "an", "An", "the", "The")
    shortWords -= articles
}
fun main() {
    val words = "A long time ago in a galaxy far far away".split(" ")
    val shortWords = mutableListOf<String>()
    words.getShortWordsTo (shortWords, 3)
    println(shortWords)//輸出 [ago, in, far, far]

}

4.List

　　List<T> 以指定的順序存儲元素，並提供使用索引訪問元素的方法。索引從 0 開始 ‒ 第一個元素的索引 ‒ 直到最后一個元素的索引即(list.size - 1) 

    val numbers = listOf("one", "two", "three", "four")
    println ("Number of elements: ${numbers.size}")
    println("Third element: ${numbers.get(2)}")
    println("Fourth element: ${numbers[3]}")
    println("Index of element \"two\" ${numbers.indexOf("two")}")

　　List元素(包括空值)可以重復:List可以包含任意數量的相同對象或單個對象的出現。如果兩個List在相同的位置具有相同大小和相同結構的元素，則認為它們是相等的

val bob = Person("Bob", 31)
val people = listOf<Person>(Person("Adam", 20), bob, bob)
val people2 = listOf<Person>(Person("Adam", 20), Person("Bob", 31), bob)
println (people == people2)
bob.age = 32
println(people == people2)

　　MutableList是可以進行寫操作的 List，例如用於在特定位置添加或刪除元素

val numbers = mutableListOf(1, 2, 3, 4) 
numbers.add(5)
numbers.removeAt(1)
numbers[0] = 0
numbers.shuffle() 
println(numbers)

　　在 Kotlin 中，List 的默認實現是 ArrayList

5.Set

　　Set<T> 存儲唯一的元素;它們的順序通常是未定義的.null元素也是唯一的:一個Set只能包含一個null.當兩個set具有相同的大小並且對於一個 set 中的每個元素都能在另一個 set 中存在 相同元素，則兩個 set 相等

val numbers = setOf(1, 2, 3, 4)
println("Number of elements: ${numbers.size}")
if (numbers.contains(1)) 
    println("1 is in the set")
val numbersBackwards = setOf(4, 3, 2, 1)
println("The sets are equal: ${numbers == numbersBackwards}")

　　MutableSet 是一個帶有來自 MutableCollection 的寫操作接口的 Set 。Set 的默認實現 - LinkedHashSet ‒ 保留元素插入的順序。因此，依賴於順序的函數，例如 first() 或 last()，會在這些 set 上返回可預測的結果。

val numbers = setOf(1, 2, 3, 4) // LinkedHashSet is the default implementation
val numbersBackwards = setOf(4, 3, 2, 1)
println(numbers.first() == numbersBackwards.first()) 
println(numbers.first() == numbersBackwards.last())

　　另一種實現方式 ‒ HashSet ‒ 不聲明元素的順序，所以在它上面調用這些函數會返回不可預測的結果。 但是，HashSet 只需要較少的內存來存儲相同數量的元素

6.Map

　　Map<K, V> 不是 Collection 接口的繼承者;但是它也是 Kotlin 的一種集合類型。Map 存儲 鍵-值 對(或條目);鍵是唯一的，但是不同的鍵可以與相同的值配對。Map 接口提供特定的函數進行通過鍵訪 問值、搜索鍵和值等操作。

val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)
println("All keys: ${numbersMap.keys}")
println("All values: ${numbersMap.values}")
if ("key2" in numbersMap) println("Value by key \"key2\": ${numbersMap["key2"]}")
if (1 in numbersMap.values) println("The value 1 is in the map")
if (numbersMap.containsValue(1)) println("The value 1 is in the map") // 同上

　　MutableMap 是一個具有寫操作的 Map 接口，可以使用該接口添加一個新的鍵值對或更新給定鍵的值。

val numbersMap = mutableMapOf("one" to 1, "two" to 2) 
numbersMap.put("three", 3)
numbersMap["one"] = 11
println(numbersMap)

　　Map默認實現 LinkedHashMap,保留元素插入的順序，使用HashMap不聲明元素的順序

7.構造集合

　　7.1 由元素構造

　　　　創建集合的最常用方法是使用標准庫函數 listOf<T>()、setOf<T>()、mutableListOf<T> ()、mutableSetOf<T>()。如果以逗號分隔的集合元素列表作為參數，編譯器會自動檢測元素類型。 創建空集合時，須明確指定類型

val numbersSet = setOf("one", "two", "three", "four") 
val emptySet = mutableSetOf<String>()

　　　　同樣的，Map 也有這樣的函數 mapOf() 與 mutableMapOf()。映射的鍵和值作為 Pair 對象傳遞(通常使用中綴函數 to 創建)。

val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)

　　　　注意，to 符號創建了一個短時存活的 Pair 對象，因此建議僅在性能不重要時才使用它。為避免過多 的內存使用，請使用其他方法。例如，可以創建可寫 Map 並使用寫入操作填充它。apply() 函數可以幫 助保持初始化流暢。

 val numbersMap = mutableMapOf<String, String>().apply { this["one"] = "1"; this["two"] = "2" }

　　7.2 空集合

　　　　還有用於創建沒有任何元素的集合的函數:emptyList()、emptySet() 與 emptyMap()。創建空集 合時，應指定集合將包含的元素類型

val empty = emptyList<String>()

　　7.3 list的初始化函數

　　　　對於 List，有一個接受 List 的大小與初始化函數的構造函數，該初始化函數根據索引定義元素的值。

val doubled = List(3, { it * 2 }) // 如果你想操作這個集合，應使用 MutableList
println(doubled)

　　7.4 具體類型構造函數

　　　　要創建具體類型的集合，例如 ArrayList 或 LinkedList，可以使用這些類型的構造函數。類似的構造函數對於Set 與Map的各實現中均有提供

val linkedList = LinkedList<String>(listOf("one", "two", "three"))
val presizedSet = HashSet<Int>(32)

　　7.5 復制

　　　　要創建與現有集合具有相同元素的集合，可以使用復制操作。標准庫中的集合復制操作創建了具有相同 元素引用的 淺 復制集合。因此，對集合元素所做的更改會反映在其所有副本中。

　　　　在特定時刻通過集合復制函數，例如toList()、toMutableList()、toSet() 等等。創建了集合的快 照。結果是創建了一個具有相同元素的新集合 如果在源集合中添加或刪除元素，則不會影響副本。副本也可以獨立於源集合進行更改。

val sourceList = mutableListOf(1, 2, 3)
val copyList = sourceList.toMutableList() 
val readOnlyCopyList = sourceList.toList()
sourceList.add(4)
println("Copy size: ${copyList.size}")
//readOnlyCopyList.add(4) // 編譯異常 
println("Read-only copy size: ${readOnlyCopyList.size}")

　　　　這些函數還可用於將集合轉換為其他類型，例如根據 List 構建 Set，反之亦然

val sourceList = mutableListOf(1, 2, 3)
val copySet = sourceList.toMutableSet()
copySet.add(3)
copySet.add(4)
println(copySet)

　　　　或者，可以創建對同一集合實例的新引用。使用現有集合初始化集合變量時，將創建新引用。因此，當通過引用更改集合實例時，更改將反映在其所有引用中

val sourceList = mutableListOf(1, 2, 3)
val referenceList = sourceList 
referenceList.add(4)
println("Source size: ${sourceList.size}")

　　　　集合的初始化可用於限制其可變性。例如，如果構建了一個 MutableList 的 List 引用，當你試圖通 過此引用修改集合的時候，編譯器會拋出錯誤

val sourceList = mutableListOf(1, 2, 3)
val referenceList: List<Int> = sourceList 
//referenceList.add(4) // 編譯錯誤
sourceList.add(4)
println(referenceList) // 顯示 sourceList 當前狀態

　　7.6 調用其他集合的函數

　　　　可以通過其他集合各種操作的結果來創建集合。例如，過濾列表會創建與過濾器匹配的新元素列表:

val numbers = listOf("one", "two", "three", "four")
val longerThan3 = numbers.filter { it.length > 3 } 
println(longerThan3)

　　　　映射生成轉換結果列表:

val numbers = setOf(1, 2, 3)
println(numbers.map { it * 3 }) 
println(numbers.mapIndexed { idx, value -> value * idx })

　　　　關聯生成 Map:

val numbers = listOf("one", "two", "three", "four") 
println(numbers.associateWith { it.length })