[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 ```