Kotlin 集合类的高阶函数

集合类：用于存放对象的引用，而非对象本身。

数据结构主要解决三个问题：

• 数据元素之间的逻辑关系：集合、线性结构、树形结构、图形结构等。
• 数据的物理结构：顺序、链表、索引、散列表、等形式。
• 数据的处理运算。

集合类主要分为：可变集合类（Mutable）和 不可变集合类（Immutable)
集合类型主要有3种：List（列表）、Set（集）和 Map（映射）

1. 列表：主要特征其对象以线性方式存储，没有特定顺序，主要包括数组、向量、链表、堆栈、队列等。
2. 集：主要特征存储不重复的对象
3. 映射：主要特征其对象的存储都是成对的，每个对象都有一个key，决定对象的存储位置。关键字的生成是通过散列（hashing）技术生成的。

List

创建不可变集合：

 	 val list:List<Int> =  listOf() //创建没有元素的集合 \<Int>这样的类型不可省略
	 val list = listOf(1) //创建只有一个元素的集合
	 val list = listOf(1,2,3,4) //创建有多个元素的集合

创建可变集合：

	  val list = mutableList<Int>()
	  val list = mutableList(1)
	  val list = mutableListOf(1,2,3)

遍历List元素：
1 使用Iterator迭代器

      val list = listOf(1, 2, 3, 4)
      val iterator = list.iterator()
      while (iterator.hasNext()) {
         println(iterator.next())
       }

2 使用forEach遍历

      val list = listOf(1, 2, 3, 4)
      val iterator = list.iterator()
      list.forEach{
            println(it)
        }

元素操作：add remove set clear /增 删 改 清除

        val mutableList = mutableListOf(1, 2, 3, 4)
        mutableList.add(0) // 添加元素
        mutableList.add(0, 3) // 在指定位置添加元素
        mutableList.addAll(listOf(4,5)) // 添加子集
        println(mutableList)
        mutableList.remove(0) // 移除元素
        mutableList.removeAt(0) // 移除指定位置的元素
        mutableList.removeAll(listOf(1,2,3)) // 移除子集
        println(mutableList)
        mutableList[0] = 111 // 更新指定位置的元素
        println(mutableList)
        mutableList.clear() // 清空元素
        mutableList.toList() // 可变集合转换为不可变集合

retainAll：取两个集合交集

        val mList1 = mutableListOf(1, 2, 34, 4, 4, 2)
        val mList2 = mutableListOf(3, 2, 4, 4, 1)
        mList1.retainAll(mList2) // 输出 mList1 中 与 mList2 相交的子集
        println(mList1)
        //print > [1, 2, 4, 4, 2]

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

根据 index 查找元素

elementAt(index：Int): T : 查找下标对应的元素，会有IndexOutOfBoundsException。

elementAtOrElse(index: Int，defaultValue：（Int) -> T) : T :查找下标对应元素，如果越界，返回默认值 eg: println(mList1.elementAtOrElse(100, {3} ))

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

关键字查找特殊元素

first() 返回集合第一个元素，如果是空集，抛出异常NoSuchElementException

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

first(predicate: (T) -> Boolean): T 返回符合条件的第一个元素，没有则抛异常NoSuchElementException

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

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

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

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

lastIndexOf(element: T): Int 返回符合条件的最后一个元素下标，没有就返回-1 等同于 indexOfLast(predicate: (T) -> Boolean): Int

根据元素查找下标

indexOf(element: T): Int 返回指定下标的元素，没有就返回-1

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

indexOfLast(predicate: (T) -> Boolean): Int 返回最后一个符合条件的元素下标，没有就返回-1

查找符合特殊条件的元素

single(): T 该集合如果只有1个元素，则返回该元素。否则，抛异常。可用于判断该集合是否只有一个元素等

none()：Boolean 判断集合无元素

any() ：Boolean 判断集合至少有一个元素

single(predicate: (T) -> Boolean): T 返回符合条件的单个元素，如有没有符合的抛异常NoSuchElementException，或超过一个的抛异常 IllegalArgumentException。

singleOrNull 处理异常结果，没有符合或超出一个，返回 null

any(predicate：(T) -> Boolean) 判断集合中是否有满足条件的元素

all(predicate：(T) -> Boolean) ：Boolean 判断集合中是否有都满足条件

none(predicate：(T) -> Boolean)：Boolean 判断集合中所有元素都不满足条件

count()：Int 计算集合中元素都个数

count(predicate：(T) -> Boolean )：Int 计算集合中满足条件都元素的个数

累计计算

reduce（operation：(acc：S，T)：S 从第一项到最后一项进行累计运算

        val mList = mutableListOf(1,2,3,4)
        val cList = mutableListOf("a","b","c")
        println(mList.reduce{first,next -> first * next}) //24
        println(cList.reduce({result,next -> result + next})) //abc

reduceRight 从最后一项到第一项进行累计运算

        val cList = mutableListOf("a","b","c")
        println(cList.reduceRight({ previous, result -> result + previous })) // cba

fold(initial：R，operation：（acc：R，T) -> R)：R 带初始值的reduce

foldRight(initial: R, operation: (T, acc: R) -> R): R ) 同理reduceRight

        println(cList.reduceRight({ previous, result -> result + previous }))

        println(cList.foldRight("N",{previous,result -> result + previous})) // Ncba

        println(cList.fold("n",{result,next -> result + next})) // nabc
 

forEach(action: (T) -> Unit): Unit 循环遍历元素，元素是it

forEachIndexed(action: (index: Int, T) -> Unit): Unit 带下标循环遍历元素

maxOrNull() / minOrNull() 返回集合中最大/最小的元素

sumBy(selector: (T) -> Int): Int 获取函数映射的总和

过滤

take(n: Int): List<T> 返回该集合前n个元素

        val list = mutableListOf(1,2,3,4,4,3,2,2,1)
        println(list.take(3)) //[1, 2, 3]
        println(list.take(100)) // [1, 2, 3, 4, 4, 3, 2, 2, 1] 返回只读数组 

takeWhile(predicate: (T) -> Boolean): List<T> 返回满足条件的前n个元素

      val list = mutableListOf(1,2,3,4,4,3,2,2,1)
      println(list.takeWhile { it % 2 == 0 }) //[] 因为第一个元素就不满足
  

takeLast(n: Int): List<T> 返回后n个元素

takeLastWhile(predicate: (T) -> Boolean): List<T> 返回满足条件到后n个元素

      val list = mutableListOf(1,2,3,4,4,3,2,2,1)
      println(list.takeLastWhile {  it < 4 }) // [3, 2, 2, 1]
      println(list.takeLast(3)) //[2, 2, 1] 注意：不是从最后一个往前添加，而是从第 size-n 个添加到 size  

drop(n: Int): List<T> 去除前 n 个元素，返回剩下的子集合

dropWhile(predicate: (T) -> Boolean): List<T> 从前向后去除满足条件的元素，当第一次不满足条件后，返回剩余不满足条件后的剩余元素。

dropLast(n: Int): List<T> 去除后几个元素的集合

dropLastWhile(predicate: (T) -> Boolean): List<T> 从后向前去除满足条件的元素，当第一次遇到不满足条件后，返回剩余元素

        val list = mutableListOf(1, 22, 33, 44, 55, 66, 77, 88)
        println(list.drop(3)) // [44, 55, 66, 77, 88]
        println(list.dropWhile { it % 2 == 0 }) // [1, 22, 33, 44, 55, 66, 77, 88] 注意 这里第一个元素就不满足，所以，返回整个数组，而不是继续过滤
        println(list.dropLast(2)) // [1, 22, 33, 44, 55, 66]
        println(list.dropLastWhile { it % 2 == 0 }) // [1, 22, 33, 44, 55, 66, 77]

过滤集合

slice(indices: IntRange): List<T> 返回指定下标的元素子集合
slice(indices: Iterable<Int>): List<T> 返回指定下标集合的元素子集

        val list = mutableListOf(1, 22, 33, 44, 55, 66, 77, 88)
        println(list.slice(2..3)) // [33, 44]
        println(list.slice(listOf(2,3,6))) // [33, 44, 77]
   

filter(predicate: (T) -> Boolean): List<T> 过滤符合条件的元素子集

filterTo(destination: C, predicate: (T) -> Boolean): C 过滤符合条件的元素给目标c

        val list = mutableListOf(1, 22, 33, 44, 55, 66, 77, 88)
        val desFilterList = mutableListOf<Int>()
        println(list.filter { it % 2 == 0 }) // [22, 44, 66, 88]
        println(list.filterTo(desFilterList,{it > 20})) // [22, 33, 44, 55, 66, 77, 88]
        println(desFilterList) // [22, 33, 44, 55, 66, 77, 88]

映射操作符

map(transform: (T) -> R): List<R> 将集合的每个元素，通过 transform 映射存到集合中并返回。

mapTo(destination: C, transform: (T) -> R): C 同理，只是将结果存入到 C 中并返回。

        val list = mutableListOf(1, 2, 3)
        val mapList  = list.map { it * 2 }
        val toMapList = mutableListOf<Int>()
        list.mapTo(toMapList,{it * 100})
        println(mapList) // [2, 4, 6]
        println(toMapList) // [100, 200, 300] 

mapNotNull(transform: (T) -> R?): List<R> 映射并剔除null元素。

flatMap(transform: (T) -> Sequence<R>): List<R>
flatMap(transform: (T) -> Iterable<R>): List<R>

分组操作符

groupBy(keySelector: (T) -> K): Map<K, List<T>> 将集合中的元素按条件选择器分组，并返回Map

groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>> 根据选择器 keySelector 和转换函数 valueTransform 分组，并返回Map

        val list = mutableListOf("qqq", "eee", "aa", "c")
        val map = list.groupBy { it.length }
        println(map) //{3=[qqq, eee], 2=[aa], 1=[c]} 简单根据长度分组
        val mapWithTransform = list.groupBy({it.length},{ it.contains("a")})
        println(mapWithTransform) // {3=[false, false], 2=[true], 1=[false]} 将 value 通过 transform 又进行了一次映射

        // 二元数组
        val mlist = listOf("K&R" to "C", "Bjar" to "C++", "Linus" to "C", "James" to "JAVA")
        // 采用第二种分组方式，分组并转换value值
        val groupMap1 = mlist.groupBy({it.second},{it}) 
        val groupMap2 = mlist.groupBy({it.second},{it.first})
        val groupMap3 = mlist.groupBy({it.second},{it.first.contains("a")})
        println(groupMap1) // {C=[(K&R, C), (Linus, C)], C++=[(Bjar, C++)], JAVA=[(James, JAVA)]}
        println(groupMap2) // {C=[K&R, Linus], C++=[Bjar], JAVA=[James]}
        println(groupMap3) // {C=[false, false], C++=[true], JAVA=[true]}

groupingBy(crossinline keySelector: (T) -> K): Grouping<T, K> 获取 Grouping ，可以通过 eachCount 来统计分组个数

        val words = "today is a cloud day".split(" ")
        val groupingBy = words.groupingBy { it.first() }
        println(groupingBy.eachCount()) // {t=1, i=1, a=1, c=1, d=1}

排序操作符

reversed(): List<T> 倒序排列集合元素。 注意：这里是返会新的倒序集合，不改变原有集合顺序。

sorted(): List<T>

sortedDescending(): List<T>

sortedBy(crossinline selector: (T) -> R?): List<T>

sortedByDescending(crossinline selector: (T) -> R?): List<T>

        val words = "today is a cloud day".split(" ")
        val newList  = words.reversed()
        println(words) // [today, is, a, cloud, day]
        println(newList) // [day, cloud, a, is, today]
        println(words.sorted()) // [a, cloud, day, is, today]
        println(words.sortedDescending()) // [today, is, day, cloud, a]
        println(words.sortedBy { it.length }) // [a, is, day, today, cloud]
        println(words.sortedByDescending { it.length }) // [today, cloud, day, is, a]
        println(words) // [today, is, a, cloud, day]

生产操作符

zip(other: Iterable<R>): List<Pair<T, R>> 将两个集合按照下标匹配，组合成新的Pair类型的集合，当两个长度不一样，取短的长度为主

        val list1 = mutableListOf(2, 2, 333, 4)
        val list2 = mutableListOf(0, 2, 1)
        val zipList1 = list1.zip(list2)
        val zipList2 = list2.zip(list1)
        println(zipList1) // [(2, 0), (2, 2), (333, 1)]
        println(zipList2) // [(0, 2), (2, 2), (1, 333)]
  

unzip(): Pair<List<T>, List<R>> 将 Pair 集合分别以 first、second 为两个数组进行返回。

        val list = mutableListOf(1 to "one", 2 to "two", 3 to "three")
        println(list.unzip()) // ([1, 2, 3], [one, two, three])

partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> 将数组分为满足和不满足条件的两个 Pair 子集。

        val list = mutableListOf(1,2,3,4,3,2,1,5,6,7,8,4,3,2)
        println(list.partition { it > 4 }) // ([5, 6, 7, 8], [1, 2, 3, 4, 3, 2, 1, 4, 3, 2])

plus(elements: Iterable<T>): List<T> 合并两个 List

plusElement(element: T): Lis<T> 添加一个元素

        val list1 = mutableListOf(1, 2, 3)
        val list2 = mutableListOf(1, 2, 3)
        println(list1.plus(list2)) // [1, 2, 3, 1, 2, 3]
        println(list1 + list2) // [1, 2, 3, 1, 2, 3]
        println(list1.plusElement(2)) // [1, 2, 3, 2]

Set

存储不重复的元素，允许存放null

HashSet：按照哈希算法存取集合中的对象，存取速度较快。
TreeSet：实现了 SortedSet 接口，能够对集合中对元素进行排序。
LinkedHashSet：具有 HashSet 的查询速度，且内部使用链表维护元素的顺序，适用于频繁的插入、删除的场景。

创建：

        var hashSet = hashSetOf(1,2) // HashSet
        var linkedHashSet = linkedSetOf(1,2) // LinkedHashSet
        var mutableSet = mutableSetOf(1,2) // LinkedHashSet
        val sortSet = sortedSetOf(1,2,3) // TreeSet

Map

HashMap：通过 hash 计算 key-value 存放的位置，允许 null key 和 null value
TreeMap：使用红黑树的 Map 接口的实现
LinkedHashMap：继承 HashMap，并实现 LinkedHashMap。是有序的集合。

containsKey(key: K): Boolean 是否包含该key。

containsValue(value: V): Boolean 是否包含该value。

component1() component2() Map.Entry<K, V> 的操作符函数，分别用来直接访问key和value。

        val map = mapOf("x" to 1, "y" to 2, "z" to 3)
        map.forEach{
            println(" key= ${it.component1()} value= ${it.component2()}")
        }
        // key= x value= 1
        // key= y value= 2
        // key= z value= 3

toPair(): Pair<K, V> = Pair(key, value) 把 Map 的 Entry 转换为 Pair

        val map = mapOf("x" to 1, "y" to 2, "z" to 3)
        map.forEach{
            println(" pair: ${it.toPair()}")
        }
		 // pair: (x, 1)
		 // pair: (y, 2)
		 // pair: (z, 3)

getOrElse(key: K, defaultValue: () -> V): V 通过key获取值，当没有值可以设置默认值。

getValue(key: K): V 没有该值会抛出异常

getOrPut(key: K, defaultValue: () -> V): V 如果不存在这个key，就添加这个key到Map中，对应的value是defaultValue。

mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V> 把Map的Key设置为通过转换函数transform映射之后的值。注意：这里的it是Map的Entry。 如果不巧，有任意两个key通过映射之后相等了，那么后面的key将
会覆盖掉前面的key。

mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R> 对应的这个函数是把Map的value设置为通过转换函数transform转换之后的新值。

filterKeys(predicate: (K) -> Boolean): Map<K, V> 返回过滤出满足key判断条件的元素组成的新Map。

filterValues(predicate: (V) -> Boolean): Map<K, V> 返回过滤出满足value判断条件的元素组成的新Map。

filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V> 返回过滤出满足Entry判断条件的元素组成的新Map。

Iterable<Pair<K, V>>.toMap(destination: M): M 把持有Pair的Iterable集合转换为Map。

        val pairList = listOf(Pair(1,"a"),Pair(2,"b"),Pair(3,"c"))
        println(pairList) // [(1, a), (2, b), (3, c)]
        println(pairList.toMap()) // {1=a, 2=b, 3=c}
  

Map<out K, V>.toMutableMap(): MutableMap<K, V> 把一个只读的Map转换为可编辑的MutableMap。

plus minus 相当于 map + Pair / map + listof(Pari()) / map + arrayOf(Pair()) / map + sequenceOf(Pair()) / map + mapOf(x to x)

put(key: K, value: V): V? putAll(from: Map<out K, V>): U 如果存在 key 更新元素，不存在 添加元素 注意 ：后面的元素会覆盖前面的元素