Kotlin集合—集合类型共性和操作

代码：

package com.init.demo.collection

/**
 * 集合类型Collection
 * Kotlin本身就提供了一组非常良好的原生集合类型接口，分为几下几种;
 *  •  Iterable：这是父类（class），意思是可迭代的、可被重复操作的（这里我们提前讲到类（class），
 *              你现在可以将类理解为函数与变量的组合，
 *              并用了个名字来代表。Iterable就是类名，类可以像基因一样被继承、繁衍而产生多样化的子类）。
 *              任何继承了此接口的类，都意味着实现了一个其中元素可以被选代（重复操作）的序列。
 *  •  Mutablelterable：支持在迭代过程中移除自身元素的lterable。
 *  •  Collection：此类代表了一组元素的通用集合。我们可以通过各种函数来访问集合，
 *                 如返回集合大小、是否为空、是否包含某个元素或一组元素。所有这些对集合的操作仅仅是请求数据，
 *                 因为集合类型是不可变的（immutable）。
 *  •  MutableCollection：一个支持添加和移除自身元素的Collection，它提供了额外的功能，如add、remove或clear等。
 *  •  List: Array主角光环下被掩盖了，其实List也是一样的功能。
 *          没错，虽然用得最多，可就是主角Array的替身，毕竟各种其他编程语言大多以Array为标准名称，
 *          因为是排序了的，我们可以通过位置（索引）请求对应的元素，使用get函数或快捷的下标中括号方法。
 *  •  MutableList：尴尬的是主角Array并没有搭配一个Mutable小老弟。所以MutableList登场了，顾名思义，
 *                 是一个支持添加和移除元素的List。
 *  •  Set：一个无序的，但其中元素并不重复的集合。
 *  •  MutableSet：一个支持添加和删除元素的Set。
 *  •  Map：键值对（Key-valuePair）的集合。
 *     其中的键具有唯一性，也就是说一个map里不能有两个一样的键（key）。
 *  •  MutableMap：一个支持添加和移除元素的Map。
 */
fun main(args: Array<String>) {
    //聚合系列：any 只要其中一个元素满足判断条件
    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(list.any { it % 2 == 0 })
    println(list.any { it > 6 })
    //聚合系列：all 所有元素满足条件
    println(list.all { it % 2 == 0 })
    println(list.all { it < 6 })
    //聚合系列：count 返回匹配条件的元素数目
    println(list.count { it % 2 == 0 })
    //聚合系列：fold 提供一个初始值，并描述第一个到最后一个元素如何依
    // 次与这个初始值计算的操作，从而实现累计
    println(list.fold(0) { total, next -> total + next })
    println(list.fold(2) { total, next -> total * next })
    //聚合系列：foldRight 与fold一样，方向相反，从右往左
    println(list.foldRight(2) { total, next -> total * next })
    //聚合系列：forEach 对每一个元素执行指定的操作
    list.forEach { println(it) }
    //聚合系列：forEachIndexed 对每一个元素执行指定的操作，可以获取元素索引
    list.forEachIndexed { index, i -> println("位置${index}的值是${i}。") }
    //聚合系列：max 获取最大的元素，没有返回null
    println(list.max())
    //聚合系列：max 获取指定函数操作后产生最大的元素，没有返回null
    println(list.maxBy { -it })
    //聚合系列：min 获取最小的元素，没有返回null
    println(list.min())
    //聚合系列：minBy 获取指定函数操作后产生最小的元素，没有返回null
    println(list.minBy { -it })
    //聚合系列：none 返回true，如果没有元素满足条件，返回false
    println(list.none())
    println(list.none { it % 2 == 0 })
    聚合系列：reduce 与fold相似 不需要初始值，并描述第一个到最后一个元素如何依
    //    // 次与这个初始值计算的操作，从而实现累计
    println(list.reduce { total, next -> total + next })
    println(list.reduce { total, next -> total * next })
    聚合系列：reduceRight  不需要初始值
    //reduce，方向相反，从右往左
    println(list.reduceRight { total, next -> total * next })
    //聚合系列：sumBy  返回经过处理过的元素的和
    println(list.sumBy { it % 2 })


    //筛选系：drop 把头n个元素丢弃后的所有元素返回
    println(list.drop(3))
    //筛选系：dropWhile 把头n个满足条件元素丢弃后的所有元素返回
    println(list.dropWhile { it < 3 })
    //筛选系：dropLast 把最后n个元素丢弃后的所有元素返回
    println(list.dropLast(3))
    //筛选系：dropLastWhile 把把最后n个满足条件元素丢弃后的所有元素返回
    println(list.dropLastWhile { it > 6 })
    //筛选系：filter 把满足条件元素所有元素返回
    println(list.filter { it % 2 == 0 })
    //筛选系：filterNot 把不满足条件所有元素返回
    println(list.filterNot { it % 2 == 0 })
    //筛选系：filterNotNull 把不为空的所有元素返回
    println(list.filterNotNull())
    //筛选系：slice 切割 按指定索引或索引范围内的元素
    println(list.slice(listOf(1, 2, 4)))
    println(list.slice(0..2))
    //筛选系：take 把头n个元素返回
    println(list.take(3))
    //筛选系：takeWhile 把头n个满足条件元素返回
    println(list.takeWhile { it < 3 })
    //筛选系：takeLast 把最后n个元素元素返回
    println(list.takeLast(3))
    //筛选系：dropLastWhile 把把最后n个满足条件元素返回
    println(list.takeLastWhile { it > 6 })
    //映射系或称变形系：flatMap 跌代集合的所有元素，为每一个元素生成一个新的集合，最后把所有集合摊平合并到一个集合里。
    println(list.flatMap { listOf(it, it + 1) })
    //映射系或称变形系：groupBy 返回一个按原集合按条件分组的map
    println(list.groupBy { if (it % 2 == 0) "偶数" else "奇数" })
    //映射系或称变形系：map 返回一个对每一个元素变换后的新集合
    println(list.map { it * 3 })
    //映射系或称变形系：mapIndexed在map的基础上 引入集合的索引变换使用
    println(list.mapIndexed { index, i -> index * i })
//    println(list.mapNotNull() } // mapNotNull 对所有非null元素进行变化 使用的很少


    //元素操作： contains 找到此元素返回true
    println(list.contains(3))
    //元素操作： elementAt 返回指定索引处的元素，如果索引不在集合的索引范围内，
    // 则抛出IndexOutOtBoundsException，即索引越界异常错误。
    println(list.elementAt(3))
    //元素操作： elementAtOrElse 如果索引越界则返回调用函数的结果
    println(list.elementAtOrElse(10) { it * 2 })
    //元素操作： elementAtOrNull 如果索引越界则返回null
    println(list.elementAtOrNull(10))
    //元素操作： first{} 返回第一个满足条件的元素
    println(list.first { it % 2 == 0 })
    //元素操作： firstOrNull 找不到满足条件第一个的元素返回null
    println(list.firstOrNull { it % 10 == 0 })
    //元素操作： indexOf 返回元素的首个索引，如果元素不存在返回-1
    println(list.indexOf(5))
    //元素操作： indexOfFirst 返回满足条件的元素的首个索引，如果元素不存在返回-1
    println(list.indexOfFirst { it % 10 == 0 })
    //元素操作： indexOfLast 返回满足条件的元素的最后一个索引，如果元素不存在返回-1
    println(list.indexOfLast { it % 9 == 0 })
    //元素操作： last{} 返回最后一个满足条件的元素
    println(list.last { it % 2 == 0 })
    //元素操作： lastIndexOf 返回元素的最后索引，如果元素不存在返回-1
    println(list.lastIndexOf(5))
    //元素操作： lastOrNull 找不到满足条件最后一个的元素，找不到元素返回-1
    println(list.lastOrNull { it % 10 == 0 })
    //元素操作： single 返回满足条件的单元素
    // 如果没找到或找到多个元素满足条件则抛出异常错误
    // llegalArgumentException: Collection contains more than one matching element.
    println(list.single { it % 5 == 0 })
    //元素操作： singleOrNull 返回满足条件的单元素
    // 如果没找到或找到多个元素满足条件则返回null
    println(list.singleOrNull { it % 2 == 0 })

    //生成系： partition 集合拆开分成l对集合，第一个集合满足条件，另一个集合是不满足条件的。
    println(list.partition { it % 2 == 0 })
    //生成系： zip 把两个集合以相同索引顺序进行配对，组成一个新集合。新集合以最短的那个集合索引为准。
    println(list.zip(listOf(100, 101, 102)))

    //排序系：reversed 返回逆转顺序后的所有元素
    println(list.reversed())
    //排序系：sorted 返回（升序）排序后的所有元素
    println(list.sorted())
    //排序系：sortedBy 返回安特定比较器（Comparator）（升序）排序后的所有元素
    println(list.sortedBy { it % 3 == 0 })
    //排序系：sortedDescending 返回（降序序）排序后的所有元素
    println(list.sortedDescending())
    //排序系：sortedByDescending返回安特定比较器（Comparator）（降序序）排序后的所有元素
    println(list.sortedByDescending { it % 3 == 0 })
}

输出：

true
true
false
false
4
45
725760
725760
1
2
3
4
5
6
7
8
9
位置0的值是1。
位置1的值是2。
位置2的值是3。
位置3的值是4。
位置4的值是5。
位置5的值是6。
位置6的值是7。
位置7的值是8。
位置8的值是9。
9
1
1
9
false
false
45
362880
362880
5
[4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
[2, 4, 6, 8]
[1, 3, 5, 7, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 5]
[1, 2, 3]
[1, 2, 3]
[1, 2]
[7, 8, 9]
[7, 8, 9]
[1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10]
{奇数=[1, 3, 5, 7, 9], 偶数=[2, 4, 6, 8]}
[3, 6, 9, 12, 15, 18, 21, 24, 27]
[0, 2, 6, 12, 20, 30, 42, 56, 72]
true
4
20
null
2
null
4
-1
8
8
4
null
5
null
([2, 4, 6, 8], [1, 3, 5, 7, 9])
[(1, 100), (2, 101), (3, 102)]
[9, 8, 7, 6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 4, 5, 7, 8, 3, 6, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1]
[3, 6, 9, 1, 2, 4, 5, 7, 8]