5.3.4 List元素操作函数

add remove set clear

这两个添加、删除操作函数是MutableList里面的。跟Java中的集合类操作类似。

创建一个可变集合：

1. >>> val mutableList = mutableListOf(1,2,3)
2. >>> mutableList
3. [1, 2, 3]

向集合中添加一个元素：

1. >>> mutableList.add(4)
2. true
3. >>> mutableList
4. [1, 2, 3, 4]

在下标为0的位置添加元素0 ：

1. >>> mutableList.add(0,0)
2. >>> mutableList
3. [0, 1, 2, 3, 4]

删除元素1 ：

1. >>> mutableList.remove(1)
2. true
3. >>> mutableList
4. [0, 2, 3, 4]
5. >>> mutableList.remove(1)
6. false

删除下标为1的元素：

1. >>> mutableList.removeAt(1)
2. 2
3. >>> mutableList
4. [0, 3, 4]

删除子集合：

1. >>> mutableList.removeAll(listOf(3,4))
2. true
3. >>> mutableList
4. [0]

添加子集合：

1. >>> mutableList.addAll(listOf(1,2,3))
2. true
3. >>> mutableList
4. [1, 2, 3]

更新设置下标0的元素值为100：

1. >>> mutableList.set(0,100)
2. 0
3. >>> mutableList
4. [100]

清空集合：

1. >>> mutableList.clear()
2. >>> mutableList
3. []

把可变集合转为不可变集合：

1. >>> mutableList.toList()
2. [1, 2, 3]
3. ```#### `retainAll`

5. 取两个集合交集：

7. ```kotlin
8. >>> val mlist1 = mutableListOf(1,2,3,4,5,6)
9. >>> val mlist2 = mutableListOf(3,4,5,6,7,8,9)
10. >>> mlist1.retainAll(mlist2)
11. true
12. >>> mlist1
13. [3, 4, 5, 6]

15. ```#### `contains(element: T): Boolean`

17. 判断集合中是否有指定元素，有就返回true，否则返回false 。
18. 代码示例：

20. ```kotlin
21. >>> val list = listOf(1,2,3,4,5,6,7)
22. >>> list.contains(1)
23. true
24. ```#### `elementAt(index: Int): T`

26. 查找下标对应的元素，如果下标越界会抛IndexOutOfBoundsException。
27. 代码示例：

29. ```kotlin
30. >>> val list = listOf(1,2,3,4,5,6,7)
31. >>> list.elementAt(6)
32. 7
33. >>> list.elementAt(7)
34. java.lang.ArrayIndexOutOfBoundsException: 7
35. at java.util.Arrays$ArrayList.get(Arrays.java:3841)

另外，针对越界的处理，还有下面两个函数：

elementAtOrElse(index: Int, defaultValue: (Int) -> T): T : 查找下标对应元素，如果越界会根据方法返回默认值。

1. >>> list.elementAtOrElse(7,{0})
2. 0
3. >>> list.elementAtOrElse(7,{10})
4. 10

elementAtOrNull(index: Int): T? : 查找下标对应元素，如果越界就返回null

1. >>> list.elementAtOrNull(7)
2. null
3. ```#### `first()`

5. 返回集合第1个元素，如果是空集，抛出异常NoSuchElementException。

7. ```kotlin
8. >>> val list = listOf(1,2,3)
9. >>> list.first()
10. 1
11. >>> val emptyList = listOf<Int>()
12. >>> emptyList.first()
13. java.util.NoSuchElementException: List is empty.
14. at kotlin.collections.CollectionsKt___CollectionsKt.first(_Collections.kt:178)

对应的有针对异常处理的函数firstOrNull(): T? :

1. >>> emptyList.firstOrNull()
2. null
3. ```#### `first(predicate: (T) -> Boolean): T`

5. 返回符合条件的第一个元素，没有则抛异常NoSuchElementException 。

7. ```kotlin
8. >>> val list = listOf(1,2,3)
9. >>> list.first({it%2==0})
10. 2
11. >>> list.first({it>100})
12. java.util.NoSuchElementException: Collection contains no element matching the predicate.

对应的有针对异常处理的函数firstOrNull(predicate: (T) -> Boolean): T? ，返回符合条件的第一个元素，没有就返回null ：

1. >>> list.firstOrNull({it>100})
2. null
3. ```#### `indexOf(element: T): Int`

5. 返回指定下标的元素，没有就返回-1

7. ```kotlin
8. >>> val list = listOf("a","b","c")
9. >>> list.indexOf("c")
10. 2
11. >>> list.indexOf("x")
12. -1
13. ```#### `indexOfFirst(predicate: (T) -> Boolean): Int`

15. 返回第一个符合条件的元素下标，没有就返回-1 。

17. ```kotlin
18. >>> val list = listOf("abc","xyz","xjk","pqk")
19. >>> list.indexOfFirst({it.contains("x")})
20. 1
21. >>> list.indexOfFirst({it.contains("k")})
22. 2
23. >>> list.indexOfFirst({it.contains("e")})
24. -1
25. ```#### `indexOfLast(predicate: (T) -> Boolean): Int`

27. 返回最后一个符合条件的元素下标，没有就返回-1 。

29. ```kotlin
30. >>> val list = listOf("abc","xyz","xjk","pqk")
31. >>> list.indexOfLast({it.contains("x")})
32. 2
33. >>> list.indexOfLast({it.contains("k")})
34. 3
35. >>> list.indexOfLast({it.contains("e")})
36. -1
37. ```#### `last()`

39. 返回集合最后一个元素，空集则抛出异常NoSuchElementException。

41. ```kotlin
42. >>> val list = listOf(1,2,3,4,7,5,6,7,8)
43. >>> list.last()
44. 8
45. >>> val emptyList = listOf<Int>()
46. >>> emptyList.last()
47. java.util.NoSuchElementException: List is empty.
48. at kotlin.collections.CollectionsKt___CollectionsKt.last(_Collections.kt:340)
49. ```#### `last(predicate: (T) -> Boolean): T`

51. 返回符合条件的最后一个元素，没有就抛NoSuchElementException

53. ```kotlin
54. >>> val list = listOf(1,2,3,4,7,5,6,7,8)
55. >>> list.last({it==7})
56. 7
57. >>> list.last({it>10})
58. java.util.NoSuchElementException: List contains no element matching the predicate.

对应的针对越界处理的lastOrNull函数：返回符合条件的最后一个元素，没有则返回null :

1. >>> list.lastOrNull({it>10})
2. null
3. ```#### `lastIndexOf(element: T): Int`

5. 返回符合条件的最后一个元素，没有就返回-1

7. ```kotlin
8. >>> val list = listOf("abc","dfg","jkl","abc","bbc","wer")
9. >>> list.lastIndexOf("abc")
10. 3
11. ```#### `single(): T`

13. 该集合如果只有1个元素，则返回该元素。否则，抛异常。

15. ```kotlin
16. >>> val list = listOf(1)
17. >>> list.single()
18. 1

20. >>> val list = listOf(1,2)
21. >>> list.single()
22. java.lang.IllegalArgumentException: List has more than one element.
23. at kotlin.collections.CollectionsKt___CollectionsKt.single(_Collections.kt:471)

25. >>> val list = listOf<Int>()

27. >>> list.single()
28. java.util.NoSuchElementException: List is empty.
29. at kotlin.collections.CollectionsKt___CollectionsKt.single(_Collections.kt:469)
30. ```#### `single(predicate: (T) -> Boolean): T`

32. 返回符合条件的单个元素，如有没有符合的抛异常NoSuchElementException，或超过一个的抛异常IllegalArgumentException。

34. ```kotlin
35. >>> val list = listOf(1,2,3,4,7,5,6,7,8)
36. >>> list.single({it==1})
37. 1
38. >>> list.single({it==7})
39. java.lang.IllegalArgumentException: Collection contains more than one matching element.

41. >>> list.single({it==10})
42. java.util.NoSuchElementException: Collection contains no element matching the predicate.

对应的针对异常处理的函数singleOrNull: 返回符合条件的单个元素，如有没有符合或超过一个，返回null

1. >>> list.singleOrNull({it==7})
2. null
3. >>> list.singleOrNull({it==10})
4. null