Kotlin学习（二）List集合类

基本语法

List集合类

Kotlin的集合分类：

可变集合类（Mutable）
不可变集合类（Immutable）

通常集合中的对象是指集合中对象的引用，集合类型主要有List(列表)，Set(集)，Map(映射)。

使用listOf()函数创建List

创建不可变List(只读)

用下面函数创建的List是只读的，不可变的、可序列化的：

listOf()用于创建没有元素的空List
listOf(vararg elements: T)用于创建拥有多个元素的List
listOf(element: T)用于创建只有一个元素的List

例如:

创建一个空list

val list : List<Int> = listOf()
Log.e(Tag,list.toString())

打印出：[]

创建多个元素的list

 val list: List<String> = listOf("1", "2", "2", "3")
 Log.e(Tag, list.toString())

打印出[1, 2, 2, 3]

List的可变集合

List的可变集合有两种：

fmutableListOf(): MutableList
arrayListOf(): ArrayList

在MutableList中，新增了add/addAll、remove/removeAll/removeAt、set、clear、retainAll等更新修改的操作函数。

使用mutableListOf()创建可变集合

  val list = mutableListOf("1", "2", "2", "3")
  list.add(0,"0") //下标0 的位置添加"0”
  Log.e(Tag, list.toString())

打印出[0, 1, 2, 2, 3]

使用toMutableList()转换函数

将一个不可变list转变为可变list，可直接调用toMutableList()

   val list = listOf("1", "2", "2", "3")
   // 调用toMutableList()函数进行转换 声明新的 mlist
        val mlist  =list.toMutableList()
        mlist.add("4")
        mlist.add(2,"22")
        Log.e(Tag, mlist.toString()) //如果现在打印list 控制台无输出结果

打印出[1, 2, 22, 2, 3, 4]

遍历List元素

使用Iterator迭代器遍历List元素

 val list = listOf("1", "2", "2", "3")
        val mlist  =list.iterator()
        while (mlist.hasNext()){
            Log.e(Tag, mlist.next())
        }

打印出：

使用for循环遍历List元素

   val list = listOf("1", "2", "2", "3")
        for (i in list.indices){
            Log.e(Tag, list[i])
        }

打印结果同上。

逆向循环

    val list = listOf("1", "2", "2", "3")
        for(i in list.size downTo 0){
            Log.e(Tag, "$i") 
        }

打印出数组下标

使用函数withIndex()遍历List元素

   val list = listOf("1", "2", "2", "3")
        for ((index, value) in list.withIndex()) {
            Log.e(Tag,"index = $index\tvalue = $value")
        }

使用forEach遍历List元素

    val list = listOf("1", "2", "2", "3")
        list.forEach {
            Log.e(Tag,it)
        }

常见的List元素操作函数

add, remove, set, clear 这些都是基本操作。

retainAll 取两个集合的交集

list1.retainAll(list2)

contains(element: T): Boolean 判断集合中是否有指定元素。

list.contains(”6“) //是否有”6“

elementAt(index: Int): T 查找下标对应的元素。

list.elementAt(1)

如果越界会抛IndexOutOfBoundsException。

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

list.elementAtOrElse(100, {0}) //默认返回0

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

list.elementAtOrNull(100) //返回null

single(predicate: (T) -> Boolean): T 返回符合条件的单个元素否则抛异常。
singleOrNull(predicate: (T) -> Boolean): T? 返回符合条件单个元素，如未找到符合的元素或找到多个元素，则返回null。

List集合运算的基本函数

any(): Boolean 判断集合元素是否为空，集合为空，返回false。list1.any()
any(predicate: (T) -> Boolean): Boolean 集合为空或没符号条件的元素返回false。list.any { it == 0}
all(predicate: (T) -> Boolean): Boolean 仅当集合中的元素都满足条件返回。truelist.all { it % 2 == 0 }
none(): Boolean 集合中没有元素，则返回true，否则返回false。list.none()
none(predicate: (T) -> Boolean): Boolean 集合中没符合匹配条件的元素返回true。list.none { it == 5 }
count(): Int 返回集合元素个数 list.count()
count(predicate: (T) -> Boolean): Int 返回符合匹配条件的元素的个数 list.count { it % 2 == 0 }
max查询最大元素，min查询最小元素，空集返回null

过滤操作函数

take(n: Int): List 根据传入的参数挑出该集合前n个元素的子集合

映射操作符

map(transform: (T) -> R): List 将集合中的元素通过转换函数transform映射后的结果，存到一个集合中返回。list.mapNotNull { it }

排序操作符

reversed(): List 倒序排列集合元素。list.reversed()
sorted(): List和sortedDescending(): List 升序排序和降序排序。list.sorted() 和list.sortedDescending()
sortedBy和sortedByDescending 可变集合MutableList的排序操作。

生产操作符

zip(other: Iterable): List

      val list1 = arrayListOf("a1", "a2", "a3")
      val list2= arrayListOf("b1", "b2", "b3", "b4")
      Log.e(Tag,list2.zip(list1).toString())

打印出[(b1, a1), (b2, a2), (b3, a3)]

plus(elements: Iterable): List 合并两个List

   val list1 = arrayListOf(0, 1, 2, 3)
   val list2 = arrayListOf(4, 5, 6, 7, 8)
   Log.e(Tag,list1.plus(list2).toString())

打印出[0, 1, 2, 3, 4, 5, 6, 7, 8]