Kotlin学习：集合<1>.List的增、删、改、查

kotlin中的List集合分为可变和不可变，如果对集合中的数据没有增、删、改的需求，那么两种方式都可用。但是如果有增、删、改的需求，就只能声明可变List(MutableList)

我们可以用listof()函数创建一个不可变List，它有3个重载函数，创建的List都是不可变的

public inline fun <T> listOf(): List<T> = emptyList()

public fun <T> listOf(vararg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList()

public fun <T> listOf(element: T): List<T> = java.util.Collections.singletonList(element)

我们可以点进listOf()函数的返回值类型List中查看一下源码

public interface List<out E> : Collection<E> {
    override val size: Int
    override fun isEmpty(): Boolean
    override fun contains(element: @UnsafeVariance E): Boolean
    override fun iterator(): Iterator<E>

    override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean

    public operator fun get(index: Int): E

    public fun indexOf(element: @UnsafeVariance E): Int

    public fun lastIndexOf(element: @UnsafeVariance E): Int

    public fun listIterator(): ListIterator<E>

    public fun listIterator(index: Int): ListIterator<E>

    public fun subList(fromIndex: Int, toIndex: Int): List<E>
}

从源码中可以看出，不可变List只有查找函数，而没有add(),remove(),clear(),set()等修改集合元素的函数。所以在平时使用List集合的时候，需要根据自己的需求来声明List集合。本人在学kotlin的过程中，就犯了这样的错误，使用listof()函数创建了一个集合，却怎么也找不到add()函数，困惑了好久！

与不可变List相对应的自然就是可变List(MutableList)了。在MutableList中，除了继承List中的那些函数外，另外新增了add/addAll、remove/removeAll/removeAt、set、clear、retainAll等更新修改的操作函数。
创建一个MutableList的对象实例跟List类似，前面加上前缀 mutable

 val mutableList = mutableListOf(1, 2, 3)
    println(mutableList)
 输出：
[1, 2, 3]

另外，我们也可以直接使用Kotlin封装的 arrayListOf 函数来创建一个可变List：

val arrayList= arrayListOf(1, 2, 3)
 println(arrayList)
 输出：
[1, 2, 3]

虽然，kotlin将List集合分为可变和不可变，但是它们之间也是可以互相转换的

    //创建一个不可变List
    val imList = listOf(4, 5, 6)
    //将不可变List转换为可变List
    imList.toMutableList()

     //创建一个可变List
    val mutableList = mutableListOf(1, 2, 3)
    //将一个可变List转换为不可变List
    mutableList.toList()

在kotlin里封装了大量的方便操作List集合的函数

增、删、改操作

     // 创建一个可变集合：
    val mutableList = mutableListOf(1, 2, 3)
    // 向集合中添加一个元素：
    mutableList.add(4)
    //[1, 2, 3, 4]

    //在下标为0的位置添加元素0
    mutableList.add(0, 0)
    //[0, 1, 2, 3, 4]

    //删除元素1 
    mutableList.remove(1)
    // [0, 2, 3, 4]

    // 删除下标为1的元素
    mutableList.removeAt(1)
    // [0, 3, 4]

    //删除子集合
    mutableList.removeAll(listOf(3, 4))
    // [0]

    // 添加子集合
    mutableList.addAll(listOf(1, 2, 3))
    // [0, 1, 2, 3]

    // 更新设置下标0的元素值为100
    mutableList.set(0, 100)
    //[100, 1, 2, 3]

    //清空集合：
    mutableList.clear()
    // []

取两个集合交集：

retainAll()

val mList1 = mutableListOf(1,2,3,4,5,6)
val mList2 = mutableListOf(3,4,5,6,7,8,9)
println(mList1.retainAll(mList2))
输出
[3, 4, 5, 6]

判断集合中是否有指定元素，有就返回true，否则返回false 。

contains()

list = listOf(1,2,3,4,5,6,7)
println(list.contains(1))
输出
true

查找下标对应的元素

elementAt() 下标越界会抛IndexOutOfBoundsException
elementAtOrElse(index: Int, defaultValue: (Int) -> T): T 下标越界会将defaultValue返回。
elementAtOrNull(index: Int): T?下标 越界返回null

示例代码
val list = listOf(1,2,3,4,5,6,7)
println(list.elementAt(6))
输出
7
list = listOf(1,2,3,4,5,6,7)
println(mutableList.elementAtOrElse(7) { 0 })
0
println(mutableList.elementAtOrNull(7))
null

获取集合第一个元素

first() 如果是emptyList()，抛出NoSuchElementException

val list = listOf(1,2,3)
println(list.first())
输出
1
val emptyList = listOf<Int>()
println(emptyList.first())
抛出异常
java.util.NoSuchElementException: List is empty.

firstOrNull() 如果是emptyList()，则返回null

emptyList.firstOrNull()
输出
null

first(predicate: (T) -> Boolean): T 返回元素，没有则抛NoSuchElementException

val list = listOf(1,2,3)
list.first({it%2==0})
输出
2
list.first({it>100})
抛出异常
java.util.NoSuchElementException: Collection contains no element matching the predicate

firstOrNull(predicate: (T) -> Boolean): T? 返回，没有就返null

list.firstOrNull({it>100})
输出
null

获取指定元素或者下标

indexOf(element: T): Int 返回集合中指定元素的第一个匹配项的下标，没有就返回-1

  val mutableList = mutableListOf(1, 2, 1, 5, 3, 4, 5)
  val indexOf = mutableList.indexOf(1)
  println(indexOf)
输出
0

indexOfFirst(predicate: (T) -> Boolean): Int 返回第一个符合给定predicate条件元素的下标，没有就返回-1

 val indexOfFirst = mutableList.indexOfFirst { it > 2 }
 println(indexOfFirst)
输出
3

indexOfLast(predicate: (T) -> Boolean): Int 返回与给定predicate函数匹配的最后一个元素的索引，如果没有此元素，则返回-1

val indexOfLast = mutableList.indexOfLast { it > 4 }
    println(indexOfLast)
输出
6

lastIndexOf(element: T): Int 返回集合中指定元素最后一次出现的下标，如果没有此元素则返回-1

val lastIndexOf= mutableList.lastIndexOf(1)
    println(lastIndexOf)
输出
2

last() 返回集合最后一个元素，emptyList则抛出异常NoSuchElementException。

 val last = mutableList.last()
    println(last)
输出
5
 val emptyList = emptyList<Int>()
    println(emptyList.last())
抛出异常
NoSuchElementException: List is empty.

last(predicate: (T) -> Boolean): T 返回符合条件的最后一个元素，没有就抛NoSuchElementException

 val matchLast= mutableList.last { it > 4 }
    println(matchLast)
输出
5
val matchLast= mutableList.last { it > 5 }
    println(matchLast)
抛出异常
 java.util.NoSuchElementException: List contains no element matching the predicate.

lastOrNull(): T? 返回最后一个元素，如果是emptyList则返回null

val lastOrNull=mutableList.lastOrNull()
    println(lastOrNull)
输出
5
 println(emptyList.lastOrNull())
输出
null

lastOrNull(predicate: (T) -> Boolean): T? 返回符合条件的最后一个元素，没有则返回null

 val matchLastOrNull = mutableList.lastOrNull { it % 2 == 0 }
    println(matchLastOrNull)
输出
4

single(): T 返回单个元素，如果集合为空或包含多个元素，则抛出异常。

val singleList= listOf(99)
val single=singleList.single()
println(single)
输出
99

val singleList= listOf(99，100)
val single=singleList.single()
抛出异常
java.lang.IllegalArgumentException: List has more than one element.

val emptyList = emptyList<Int>()
emptyList.single()
抛出异常
java.util.NoSuchElementException: List is empty.

singleOrNull(): T? 返回单个元素，如果集合为空或者包含多个元素则返回null

val singleList= listOf(99)
val single=singleList.singleOrNull()
println(single)
输出
99

val singleList= listOf(99，100)
val single=singleList.singleOrNull()
输出
null

val emptyList = emptyList<Int>()
emptyList.singleOrNull()
输出
null

single(predicate: (T) -> Boolean): T 返回与给定predicate匹配的单个元素，如果没有或有多个匹配元素，则抛出异常。

 val singleList = listOf(89, 99, 100)
 val matchSingle = singleList.single { it == 99 }
    println(matchSingle)
输出
99

//没有匹配条件的元素
val singleList = listOf(89, 99, 100)
val matchSingle = singleList.single { it == 79 }
抛出异常
java.util.NoSuchElementException: Collection contains no element matching the predicate.

//有多个匹配条件的元素
val singleList = listOf(89,89, 99, 100)
val matchSingle = singleList.single { it == 89 }
抛出异常
java.lang.IllegalArgumentException: Collection contains more than one matching element.

singleOrNull(predicate: (T) -> Boolean): T? 返回与给定predicate匹配的单个元素，如果没有或有多个匹配元素，返回null。

 val singleList = listOf(89, 99, 100)
 val matchSingle = singleList.single { it == 99 }
    println(matchSingle)
输出
99

//没有匹配条件的元素
val singleList = listOf(89, 99, 100)
val matchSingle = singleList.single { it == 79 }
输出
null

//有多个匹配条件的元素
val singleList = listOf(89,89, 99, 100)
val matchSingle = singleList.single { it == 89 }
输出
null