[TOC] ### list集合常見方法和屬性 集合可以理解為是一個容器，容器操作我們自然想到“增刪改查”，但是需要注意可寫集合才有“增刪改查”，不可寫集合只有“查”。 #### 添加元素：add、addAll 添加元素，主要有如下幾種方式： 使用add方法直接追加元素，返回添加成功與否，方法簽名如下： ```java overridefun add(element:E): Boolean ``` 使用add方法在指定位置添加元素，無返回值，方法簽名如下： ```java publicfun add(index:Int, element: E): Unit ``` 使用addAll方法批量添加集合，返回添加成功與否，方法簽名如下： ```java overridefun addAll(elements:Collection<E>): Boolean ``` 使用addAll方法批量添加數組，返回添加成功與否，方法簽名如下： ```java publicfun <T> MutableCollection<in T>.addAll(elements:Array<out T>): Boolean ``` 使用addAll方法在指定位置批量添加元素，返回添加成功與否，addAll方法的方法簽名如下： ```java publicfun addAll(index:Int, elements: Collection<E>): Boolean ``` 上面的方法，我們編寫一個案例，驗證下，參考代碼： ~~~ fun main(args: Array<String>) { val list = mutableListOf(1, 2, 3) //追加元素 val isSuccess = list.add(4) println(list) println("添加元素成功：${isSuccess}") //添加到指定位置 list.add(0, 5) println(list) //批量添加一個集合 list.addAll(listOf(11, 22)) println(list) //批量添加一個數組 list.addAll(arrayOf(111, 222)) println(list) //在指定位置批量添加一個集合 list.addAll(0, listOf(1111, 2222)) println(list) } ~~~ 運行結果 ``` [1, 2, 3, 4] 添加元素成功：true [5, 1, 2, 3, 4] [5, 1, 2, 3, 4, 11, 22] [5, 1, 2, 3, 4, 11, 22, 111, 222] [1111, 2222, 5, 1, 2, 3, 4, 11, 22, 111, 222] Process finished with exit code 0 ``` #### 刪除元素：remove、removeAt、removeAll 刪除元素，主要有如下幾種方式：  我們編寫一個案例，驗證下上面這些方法，參考代碼： ~~~ fun main(args: Array<String>) { val list = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8) //刪除指定元素 val isSuccess = list.remove(8) println(list) println("刪除元素是否成功:$isSuccess") //刪除指定位置的元素 val removeElement = list.removeAt(0) println(list) println("元素${removeElement}被刪除了") //批量刪除，傳遞集合 list.removeAll(listOf(2, 3)) println(list) //批量刪除，傳遞數組 list.removeAll(arrayOf(4, 5)) println(list) } ~~~ 運行結果 ``` [1, 2, 3, 4, 5, 6, 7] 刪除元素是否成功:true [2, 3, 4, 5, 6, 7] 元素1被刪除了 [4, 5, 6, 7] [6, 7] Process finished with exit code 0 ``` #### 修改元素：set、下標 集合的修改，要通過set方法和下標操作，在Java里面是不可以通過下標操作的，Kotlin中支持下標修改集合。至于下標訪問的原理，后面學了操作符重載之后就明白了，在這里，我們可以先把握使用。 我們看看set方法的方法簽名： ~~~ public operator fun set(index: Int, element: E): E ~~~ 這里估計大家不懂的就是“operator”這個關鍵字是什么意思。這個到后期講解操作符重載就知道了。 我們通過一個案例，來看看集合的修改操作，參考代碼： ~~~ fun main(args: Array<String>) { //修改指定位置元素，通過set方法 val newList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8) println("修改前的newList：${newList}") val element = newList.set(0, 11) println("修改后的newList：${newList}") println("元素${element}被修改了") //修改指定位置元素，通過下標 newList[1] = 22 println("修改后的newList：${newList}") } ~~~ 運行結果 ``` 修改前的newList：[1, 2, 3, 4, 5, 6, 7, 8] 修改后的newList：[11, 2, 3, 4, 5, 6, 7, 8] 元素1被修改了 修改后的newList：[11, 22, 3, 4, 5, 6, 7, 8] Process finished with exit code 0 ``` #### 查詢元素：get、getOrNull 集合的修改，要通過get、getOrNull方法，下標操作。在Java里面是不可以通過下標操作的，Kotlin中支持下標修改集合。至于下標訪問的原理，后面學了操作符重載之后就明白了，在這里，我們可以先把握使用。 get方法，根據位置返回元素，方法簽名如下： ~~~ public operator fun get(index: Int): E ~~~ 同set方法，get方法的申明上也有一個“operator”。 getOrNull方法，也是根據位置返回元素，如果獲取不到元素的時候，返回null，方法簽名如下： ```java publicfun <T> List<T>.getOrNull(index: Int): T? { ??? return if (index >= 0 && index <= lastIndex) get(index) else null } ``` 我們通過一個案例，來看看集合的查詢操作，參考代碼： ~~~ fun main(args: Array<String>) { //修改指定位置元素，通過set方法 val newList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8) println("修改前的newList：${newList}") val element = newList.set(0, 11) println("修改后的newList：${newList}") println("元素${element}被修改了") //修改指定位置元素，通過下標 newList[1] = 22 println("修改后的newList：${newList}") //獲取指定位置的元素，通過get方法 var elementWithIndex: Int? = newList.get(0) println("集合第1個位置元素是：${elementWithIndex}") //獲取指定位置元素，通過下標 elementWithIndex = newList[1] println("集合第2個位置元素是：${elementWithIndex}") //獲取指定位置元素，通過getOrNull，獲取成功就返回元素 elementWithIndex = newList.getOrNull(2) println("集合第3個位置元素是：${elementWithIndex}") elementWithIndex = newList.getOrNull(99) //獲取指定位置元素，通過getOrNull，獲取失敗就返回null println("集合第100個位置元素是：${elementWithIndex}") } ~~~ 運行結果 ``` 修改前的newList：[1, 2, 3, 4, 5, 6, 7, 8] 修改后的newList：[11, 2, 3, 4, 5, 6, 7, 8] 元素1被修改了 修改后的newList：[11, 22, 3, 4, 5, 6, 7, 8] 集合第1個位置元素是：11 集合第2個位置元素是：22 集合第3個位置元素是：3 集合第100個位置元素是：null Process finished with exit code 0 ``` #### 是否包含元素：contains方法 判斷元素是否包含，list集合提供了contains方法和containsAll方法。 contains方法用于判斷集合中是否存包含某個元素，方法接收參數為元素，返回值Boolean類型，方法定義如下： ```java contains(element: T): Boolean ``` contains方法用于判斷集合中是否存包含多個元素，方法接收一個集合，返回值Boolean類型，方法定義如下： ```java override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean ``` 我們通過一個案例，來看看集合的原始是否包含操作，參考代碼： ~~~ fun main(args: Array<String>) { val list = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8) //是否包含某元素 var isContains = list.contains(1) println("是否包含元素1：${isContains}") //是否包含集合 isContains = list.containsAll(listOf(1, 2, 3)) println("是否包含集合[1,2,3]：${isContains}") isContains = list.containsAll(listOf(11, 22, 33)) println("是否包含集合[11,22,33]：${isContains}") } ~~~ 運行結果 ``` 是否包含元素1：true 是否包含集合[1,2,3]：true 是否包含集合[11,22,33]：false Process finished with exit code 0 ``` #### 獲取元素索引：indexOf方法 indexOf()獲取元素對應的位置，從集合開始位置開始查找，找到返回索引，沒有找到返回-1。方法簽名如下： ```java public fun indexOf(element: @UnsafeVarianceE): Int ``` lastIndexOf獲取元素對應的位置，從集合結束位置開始查找，找到返回索引，沒有找到返回-1。方法簽名如下： ```java public fun lastIndexOf(element: @UnsafeVariance E): Int ``` 我們通過一個案例，來看看集合的是否包含，參考代碼： ~~~ fun main(args: Array<String>) { val list = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8) //獲取元素的索引 var index=list.indexOf(2) println("元素2的正向索引是：${index}") index=list.lastIndexOf(2) println("元素2的反向索引是：${index}") index=list.indexOf(15) println("元素15的正向索引是：${index}") } ~~~ 運行結果 ``` 元素2的正向索引是：1 元素2的反向索引是：1 元素15的正向索引是：-1 Process finished with exit code 0 ``` #### 獲取數組長度:size屬性、count方法 同數組，獲取長度可以通過size屬性和count方法去獲取，參考代碼： ~~~ fun main(args: Array<String>) { val list = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8) //獲取集合長度 println("集合list的長度是：${list.size}") println("集合list的長度是：${list.count()}") //是否包含某元素 var isContains = list.contains(1) println("是否包含元素1：${isContains}") //是否包含集合 isContains = list.containsAll(listOf(1, 2, 3)) println("是否包含集合[1,2,3]：${isContains}") isContains = list.containsAll(listOf(11, 22, 33)) println("是否包含集合[11,22,33]：${isContains}") //獲取元素的索引 var index = list.indexOf(2) println("元素2的正向索引是：${index}") index = list.lastIndexOf(2) println("元素2的反向索引是：${index}") index = list.indexOf(15) println("元素15的正向索引是：${index}") } ~~~ 運行結果 ``` 集合list的長度是：8 集合list的長度是：8 是否包含元素1：true 是否包含集合[1,2,3]：true 是否包含集合[11,22,33]：false 元素2的正向索引是：1 元素2的反向索引是：1 元素15的正向索引是：-1 Process finished with exit code 0 ``` #### 批量處理 正如前面的示例講解一樣，其中也涉及到了集合的批量處理操作，這里我們做一個總結 ##### 不可變List集合的批量處理 ``` fun main(args: Array<String>) { val list1: List<Int> = listOf(0, 1, 2) val list2: List<Int> = listOf(0, 1, 2, 3) if (list2.containsAll(list1)) { //判斷list2是否包含list1 println("list2集合包含list1集合") } } ``` 運行結果 ``` list2集合包含list1集合 ``` >[info]注意：這里的數據類型是List，不可變list集合，查看[官網](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/index.html)，可以知道，不可變list集合沒有addAll、removeAll、clear等這些可以改變list集合的方法 ##### MutableList集合的批量操作 ``` fun main(args: Array<String>) { val muList1: MutableList<String> = mutableListOf("北京", "上海") val muList2: MutableList<String> = mutableListOf("北京", "上海", "深圳") muList2.removeAll(muList1) println("muList2移除muList1后的元素為：" + muList2) muList2.addAll(muList1) println("muList2添加muList1后的元素為：" + muList2) if (muList2.retainAll(muList1)) { println("muList2包含muList1") } else { println("muList2不包含muList1") } muList2.clear() println("muList2清除所有元素后，該集合的元素個數為：" + muList1.size) } ``` 運行結果 ``` muList2移除muList1后的元素為：[深圳] muList2添加muList1后的元素為：[深圳, 北京, 上海] muList2包含muList1 muList2清除所有元素后，該集合的元素個數為：2 ```