1 簡介

在 Kotlin 中集合主要分為可變集合與只讀集合，其中可變集合使用 “Mutable” 前綴 + 集合類名表示，比如 MutableList、MutableSet、MutableMap 等。而對于只讀集合就是和 Java 中集合類名是一致。 Java 中的 List 非 Kotlin 中的 List , 因為 Kotlin 中的 List 是只讀的而非可變，卻有點類似于 Kotlin 中的 MutableList 。

1. 只讀集合:
   內(nèi)部只具有訪問元素的方法，不具有類似 add、remove、clear 之類修改集合的方法。比如 Collection 只讀集合內(nèi)部就沒有 add、remove、clear 之類方法，只有 get 訪問元素的方法.
2. 可變集合：
   在集合內(nèi)部既具有訪問元素的方法，也具有類似 add、remove、clear 之類修改集合的方法。比如 MutableCollection 可變集合內(nèi)部就有 add、remove、clear 之類方法。

集合是可變數(shù)量的一組條目。
List : 是有序集合，可以通過下標訪問元素，元素可以重復。
Set : 是無序集合，有別于List集合的地方在于，1.沒有下標，2.元素不允許重復。只能遍歷獲取參數(shù)，遍歷參數(shù)的順序與添加順序相同。元素如果已經(jīng)存在不進行添加?？梢源鎯ull， 而且Null也是唯一的。
Map：是無序集合，通過鍵值對存儲數(shù)據(jù)。每個鍵唯一。值可以重復。

集合主要就是List、Set、Map，它們在Java中都有接口可以實現(xiàn)，
List --> ArrayList、LinkedList
Set --> HashSet
Map–> HashMap

1.1 List集合

	val list = ArrayList<String>()list.add("1")list.add("2")// 創(chuàng)建的是一個不可變的集合，該集合創(chuàng)建成功只能用于讀取數(shù)據(jù)，不能增刪改集合數(shù)據(jù)。val list1 = listOf("aa", "bb")// 創(chuàng)建的是一個可變的集合，可以進行增刪改查操作。val list2 = mutableListOf("cc", "dd")// 遍歷List集合需要使用for-in循環(huán)進行遍歷for (content in list1){// 把遍歷內(nèi)容大寫content.toUpperCase()print(content)	// 輸出：aa bb}list2.add("ee")list2.addAll(list1)// 移除指定的元素對象。如果指定元素不存在，移除null。不會報錯list2.remove("ee")// 移除參數(shù)集合中存在的所有元素。 // 或者，你可以關(guān)鍵字作為參數(shù)來調(diào)用它；在這種情況下，函數(shù)移除關(guān)鍵字匹配true 的所有元素。list2.removeAll(list1)// retainAll() 與 removeAll() 相反，// 它移除除參數(shù)集合中的元素之外的所有元素。// 當與關(guān)鍵字一起使用時，它只留下與關(guān)鍵字匹配的元素。list2.retainAll(list)

1.2 Set集合

Set和List的用法其實一樣，在初始化時會用到這幾個方法：setof()、mutableSetOf()

	// 不可變的集合val set1 = setOf("aa", "bb") // 可變的集合val set2 = mutableSetOf("cc", "dd") // 新增元素set2.add("ee")set2.addAll(set1)// 移除指定的元素對象。如果指定元素不存在，移除null。不會報錯set2.remove("ee")// 移除參數(shù)集合中存在的所有元素。 // 或者，你可以關(guān)鍵字作為參數(shù)來調(diào)用它；在這種情況下，函數(shù)移除關(guān)鍵字匹配true 的所有元素。set2.removeAll(set1)// retainAll() 與 removeAll() 相反，// 它移除除參數(shù)集合中的元素之外的所有元素。// 當與關(guān)鍵字一起使用時，它只留下與關(guān)鍵字匹配的元素。set2.retainAll(set1)

setof()：創(chuàng)建的是一個不可變的集合，該集合創(chuàng)建成功只能用于讀取數(shù)據(jù)，不能增刪改集合數(shù)據(jù)。
mutableSetOf()：創(chuàng)建的是一個可變的集合，可以進行增刪改查操作。
在這里，Set集合List集合的區(qū)別需要注意的是，Set底層是使用Hash映射機制來存儲數(shù)據(jù)的，因此集合中的元素無法保證有序。
----遍歷和List一樣，就不做解釋了

1.3 Map集合

Map集合這里重點介紹，Map和前兩者不同，Map是一種鍵值對形式的數(shù)據(jù)結(jié)構(gòu)，因此在用法上和List、Set存在很大不同。
一般初始化Map時都需要創(chuàng)建一個HashMap

val map = HashMap<String, String>()
map.put("aa", "1")
map.put("bb", "2")// 因為在Kotlin中，并不建議使用put()、get()方法對Map進行添加和讀取數(shù)據(jù)，
// 而是使用這種類似下標的方式添加數(shù)據(jù)：
val map1 = HashMap<String, Int>()
map1["aa"] = 1
map1["bb"] = 2// 當讀取數(shù)據(jù)時
val text = map1["aa"]// 移除對應的值，參數(shù)為key
map1.remove("aa")

然而，上面這種添加數(shù)據(jù)方式依然很繁瑣，和List、Set一樣，Map也有自己的方法mapof()、mutableMapOf()

// 不可變
val map1 = mapOf("aa" to 1, "bb" to 2)  
// 可變
val map2 = mutableMapOf("aa" to 1, "bb" to 2)  

mapof()：創(chuàng)建的是一個不可變的集合，該集合創(chuàng)建成功只能用于讀取數(shù)據(jù)，不能增刪改集合數(shù)據(jù)。
mutableMapOf()：創(chuàng)建的是一個可變的集合，可以進行增刪改查操作。
遍歷Map集合，也是使用的for-in循環(huán)，唯一區(qū)別在于，for-in循環(huán)中，map鍵值對變量一起申明到了一對括號中

fun main(){val map1 = mapOf("aa" to 1, "bb" to 2) for ((content1, content2) in map1){print（content1 + "--" + content2）}
}

1.4 集合迭代器 Iterator

提供一種遍歷集合元素的方法，而不暴露集合內(nèi)部的實現(xiàn)。

1.4.1 迭代器的方式

只要實現(xiàn)了Iterable接口的類型，都提供迭代器。
下面是使用迭代器的3種方式：

1. 使用next()

val numbers = listOf("one", "two", "three", "four")
val numbersIterator = numbers.iterator()
while (numbersIterator.hasNext()) {println(numbersIterator.next())
}

2. 使用for…in

val numbers = listOf("one", "two", "three", "four")
for (item in numbers) {println(item)
}

3. 使用forEach()

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

1.4.2 List 的迭代器

List 的迭代器是ListIterator類型，可以反向迭代：

val numbers = listOf("one", "two", "three", "four")
val listIterator = numbers.listIterator()
while (listIterator.hasNext()) listIterator.next()
println("Iterating backwards:")
while (listIterator.hasPrevious()) {print("Index: ${listIterator.previousIndex()}")println(", value: ${listIterator.previous()}")
}// Iterating backwards:
// Index: 3, value: four
// Index: 2, value: three
// Index: 1, value: two
// Index: 0, value: one

1.4.3 可變迭代器

可變集合（MutableList, MutableSet, MutableMap）的迭代器都是MutableIterator類型，可以在迭代的過程中調(diào)用remove()方法刪除元素。

val numbers = mutableListOf("one", "two", "three", "four") 
val mutableIterator = numbers.iterator()mutableIterator.next()
mutableIterator.remove()println("After removal: $numbers")
// After removal: [two, three, four]

另外，MutableList的迭代器是MutableListIterator類型，可以在迭代過程中插入或替換元素。

val numbers = mutableListOf("one", "four", "four") 
val mutableListIterator = numbers.listIterator()mutableListIterator.next()
mutableListIterator.add("two")
mutableListIterator.next()
mutableListIterator.set("three")println(numbers)
// [one, two, three, four]

1.5 集合Range

使用rangeTo()可以創(chuàng)建范圍，rangeTo()對應的操作符：…。

// 遍歷范圍
for (i in 1..4) print(i)// 反序遍歷：
for (i in 4 downTo 1) print(i)// 反序遍歷2:
for (i in (1..4).reversed()) print(i)// 定義步長：
for (i in 1..8 step 2) print(i)// 不包含末尾元素：
for (i in 1 until 10) print(i)

1.6 集合序列 Sequence

序列和迭代器的差別
對Iterable遍歷執(zhí)行多步操作時，會先對所有元素執(zhí)行一個步驟，將結(jié)果保存到中間集合中，然后再對中間集合中所有元素執(zhí)行下一個步驟，以此類推。相當于，所有元素被并行處理。

對Sequence遍歷執(zhí)行多步操作時，會對一個元素執(zhí)行所有步驟，然后再對下一個元素執(zhí)行所有步驟，以此類推。相當于，所有元素被串行處理。

// 1.通過元素創(chuàng)建
val s1 = sequenceOf(1, 2, 3)// 2.通過Iterable創(chuàng)建
val list = listOf(1,2,3)
val s2 = list.asSequence()// 3.通過generateSequence()函數(shù)創(chuàng)建// 4.通過sequence()創(chuàng)建// 例子：假設有很多單詞，我們要過濾長度超過3個字母的單詞，然后打印前4個這種單詞的長度。
// Iterable的方式
val words = "The quick brown fox jumps over the lazy dog".split(" ")
val lengthsList = words.filter { println("filter: $it"); it.length > 3 }.map { println("length: ${it.length}"); it.length }.take(4)
println("Lengths of first 4 words longer than 3 chars:")
println(lengthsList)// Sequence的方式
val words = "The quick brown fox jumps over the lazy dog".split(" ")
// 將 List 轉(zhuǎn)換為序列
val wordsSequence = words.asSequence()
val lengthsSequence = wordsSequence.filter { println("filter: $it"); it.length > 3 }.map { println("length: ${it.length}"); it.length }.take(4)
println("Lengths of first 4 words longer than 3 chars")
// 終止操作: 以 List 形式獲取結(jié)果
println(lengthsSequence.toList())

1. filter()、map()和take()這些操作，在調(diào)用toList()后才開始執(zhí)行。與上面Iterable相比，是”lazy“的。
2. 當結(jié)果元素數(shù)量到達4個時，會停止處理，因為take(4)指定了最大元素數(shù)量。與上面Iterable相比，節(jié)省了操作步驟。
3. Sequence處理執(zhí)行了 18 步，而使用Iterable時則需要 23 步。

1.7 常用的集合函數(shù)式API

1.7.1 map()函數(shù)

它用于將每個元素都映射成一個另外的值，映射規(guī)則在Lambda表達式中指定，最終生成一個新的集合，

val list1 = listOf("aa", "bb") 
var newList = list1.map{ it.toUpperCase()}
for (content in list1){content.toUpperCase() //轉(zhuǎn)換成大寫模式
}

1.7.2 filter()函數(shù)

用于過濾集合中的數(shù)據(jù)，可以單獨使用，也可以和map（）一起使用

val list1 = listOf("aa", "bbbb", "cc") 
var list2 = list1.filter { it.length <= 2 }.map { it.toUpperCase() }

1.7.3 any()函數(shù)

判斷集合中是否至少存在一個元素滿足指定條件

val list1 = listOf("aa", "bbbb", "cc") 
var anyResult = list1.any { it.length <= 2 }

1.7.4 all()函數(shù)

判斷集合中是否所有元素都滿足指定條件

val list1 = listOf("aa", "bbbb", "cc") 
var allResult = list1.all { it.length <= 2 }

1.7.5 maxBy()函數(shù)

定義一個集合，然后找出里面長度最長的元素，maxBy的工作原理是根據(jù)傳入的條件來進行遍歷，從而找打最大值

val list1 = listOf("aa", "bbbb", "cc") 
var maxLength = list1.maxBy { it.length }
print(maxLength)