Kotlin集合操作符整理汇总Iterable/Collection/List/Set/Map

秒速五厘米 2023-03-01 12:44 3阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh_size_16_color_FFFFFF_t_70]  
Kotlin的集合类虽然继承自Java，但是增加了更多能力，使用更具优势

*  分为`immutable`和`mutable`两类，默认的immutable类型使用起来更安全
 *  提供更多工厂方法创建对象，例如`listOf`，`setOf`等
 *  提供了很多类似于StreamAPI的操作符（本质是扩展函数），例如`filter()`等

# 接口体系 #

--------------------

`List`、`Set`、`Map`等常用集合类的继承体系与JDK基本一样，只是接口类型默认是immutable的，没有定义用于改变集合对象的“写”方法。可写的集合类需要通过另一套`MutableXXX`接口实现  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh_size_16_color_FFFFFF_t_70 1]

# Java的兼容 #

--------------------

Kotlin中调用Java代码时，集合类会自动转换，  
例如 `java.util.Iterator`转换为`kotlin.collection.Iterator`，  
因此，即使Java集合类对象也可以使用Kotlin集合操作符进行操作

# 创建集合 #

--------------------

Kotlin鼓励使用工厂模式创建集合，提供了多种工厂放阿飞

## immutable集合 ##

val list = listOf(1, 2, 3)
    val map = mapOf("foo" to "FOO", "bar" to "BAR")
    val set = setOf(9, 8, 7)

1.4新增了创建不含有null的集合的`listOfNotNull`

fun main(args: Array<String>) { 
        val list = listOf(null, 1, 2, 3, null)
        val notNullList = listOfNotNull(null, 1, 2, 3, null)
    
        println(list)
        println(notNullList)
    }

#运行结果
    [null, 1, 2, 3, null]
    [1, 2, 3]

## mutable集合 ##

val list = mutableListOf(1, 2, 3)
    val map = mutableMapOf("foo" to "FOO", "bar" to "BAR")
    val set = mutableSetOf(9, 8, 7)

## Java结合类 ##

对Java的各集合类型也提供了工厂方法，但因为创建的对象都是mutable的，所以并不推荐使用。

fun main(args: Array<String>) { 
        printClass("arrayListOf", arrayListOf<Int>())
    
        printClass("hashSetOf", hashSetOf<Int>())
        printClass("linkedSetOf", linkedSetOf<Int>())
        printClass("sortedSetOf", sortedSetOf<Int>())
    
        printClass("hashMapOf", hashMapOf<Int, Int>())
        printClass("linkedMapOf", linkedMapOf<Int, Int>())
        printClass("sortedMapOf", sortedMapOf<Int, Int>())
    }
    
    fun printClass(functionName: String, collection: Any) { 
        println("$functionName = ${ collection.javaClass}")
    }

# 结果
    arrayListOf = class java.util.ArrayList
    
    hashSetOf = class java.util.HashSet
    linkedSetOf = class java.util.LinkedHashSet
    sortedSetOf = class java.util.TreeSet
    
    hashMapOf = class java.util.HashMap
    linkedMapOf = class java.util.LinkedHashMap
    sortedMapOf = class java.util.TreeMap

# 属性 #

--------------------

## indices ##

`indices`是`index`的复数形式。  
顾名思义，其存储着Array或Collection中index的`IntRange`

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 3)
    
        val indices: IntRange = list.indices
        println(indices)
    
        for (i in list.indices) { 
            println(list[i])
        }
    }

#结果
    0..2
    1
    2
    3

## lastIndex ##

最后一个元素的index，相当于`size-1`

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 3)
    
        println(list.lastIndex)
    }

#结果
    2

# 操作符 #

--------------------

Kotlin集合操作符数量众多，基本上可以覆盖StreamAPI的所有功能

<table> 
 <thead> 
  <tr> 
   <th align="left">Steam</th> 
   <th align="left">Kotlin</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Stream.allMatch()</td> 
   <td align="left">Iterable.all(), Map.all()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.anyMatch()</td> 
   <td align="left">Iterable.any(), Map.any()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.count()</td> 
   <td align="left">Iterable.count(), Map.count()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.distinct()</td> 
   <td align="left">Iterable.distinct()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.filter()</td> 
   <td align="left">Iterable.filter(), Map.filter()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.findFirst()</td> 
   <td align="left">Iterable.first(), Iterable.firstOrNull()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.flatMap()</td> 
   <td align="left">Iterable.flatMap(), Map.flatMap()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.forEach()</td> 
   <td align="left">Iterable.forEach(), Map.forEach()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.limit()</td> 
   <td align="left">Iterable.take()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.map()</td> 
   <td align="left">Iterable.map(), Map.map()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.max()</td> 
   <td align="left">Iterable.max(), Map.maxBy()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.min()</td> 
   <td align="left">Iterable.min(), Map.minBy()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.noneMatch()</td> 
   <td align="left">Iterable.none(), Map.none()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.peek()</td> 
   <td align="left">–</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.reduce()</td> 
   <td align="left">Iterable.reduce()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.sorted()</td> 
   <td align="left">Iterable.sorted()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.skip()</td> 
   <td align="left">–</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.collect(toList())</td> 
   <td align="left">Iterable.toList(), Map.toList()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.collect(toMap())</td> 
   <td align="left">Iterable.toMap()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.collect(toSet())</td> 
   <td align="left">Iterable.toSet()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.collect(joining())</td> 
   <td align="left">Iterable.joinToString()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.collect(partitioningBy())</td> 
   <td align="left">Iterable.partition()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.collect(groupingBy())</td> 
   <td align="left">Iterable.groupBy()</td> 
  </tr> 
  <tr> 
   <td align="left">Stream.collect(reducing())</td> 
   <td align="left">Iterable.fold()</td> 
  </tr> 
  <tr> 
   <td align="left">IntStream.sum()</td> 
   <td align="left">Iterable.sum()</td> 
  </tr> 
  <tr> 
   <td align="left">IntStream.average()</td> 
   <td align="left">Iterable.average()</td> 
  </tr> 
 </tbody> 
</table>

接下来，根据Interface分别介绍各操作符的使用：

# Iterable #

--------------------

## all() ##

所有元素均命中判断条件，返回true

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.all {  it < 4 })
        println(iterable.all {  it < 3 })
    }

true
    false

## any() ##

任意元素命中判断条件，返回`true`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.any {  it < 4 })
        println(iterable.any {  it < 0 })
    }

true
    false

## associate() ##

集合转为map，元素为key

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        val map = iterable.associate {  it to it*10 }
    
        println(map)
    }

{1=10, 2=20, 3=30}

## associateBy() ##

集合转为`Map`，元素为value

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        val map = iterable.associateBy {  it*10 }
    
        println(map)
    }

{10=1, 20=2, 30=3}

## average() ##

元素平均值。元素类型必须为`Integer`、`Float`等数字类型

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        val average = iterable.average()
    
        println(average)
    }

2.0

## contains() ##

判断是否含有指定元素

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.contains(2))
        println(iterable.contains(4))
    }

true
    false

## count() ##

元素个数 or 满足lambda条件的元素个数

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.count())
        println(iterable.count { it % 2 == 1})
    }

3
    2

## distinct() ##

去重

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 1, 2, 2, 3, 1, 3)
    
        println(iterable.distinct())
    }

[1, 2, 3]

## distinctBy() ##

根据lambda去重

fun main(args: Array<String>) { 
        val iterable = listOf("foo", "bar", "fizz", "buzz", "hoge")
    
        println(iterable.distinctBy {  it.length })
    }

[foo, fizz]

## drop() ##

丢弃某元素

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.drop(2))
    }

[3, 4, 5]

## dropWhile() ##

根据lambda丢弃元素

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.dropWhile {  it != 4 })
    }

[4, 5]

## elementAt() ##

获取指定元素，参数非法时会`IndexOutOfBoundsException`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.elementAt(2))
    }

## elementAtOrElse() ##

获取指定元素，参数非法时返回lambda的结果

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.elementAtOrElse(0, {  it * 10 }))
        println(iterable.elementAtOrElse(5, {  it * 10 }))
    }

1
    50

## elementAtOrNull() ##

获取指定元素，参数非法时返回`null`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.elementAtOrNull(0))
        println(iterable.elementAtOrNull(5))
    }

1
    null

## filter() ##

lambda条件过滤

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.filter {  it % 2 != 0 })
    }

[1, 3]

## filterIsInstance() ##

过滤指定类型的元素

fun main(args: Array<String>) { 
        val iterable: Iterable<*> = listOf(1, "foo", 2.4, false)
    
        println(iterable.filterIsInstance<Number>())
        println(iterable.filterIsInstance(String::class.java))
    }

[1, 2.4]

## filterNot() ##

抛弃符合条件的元素

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.filterNot {  it % 2 == 0 })
    }

[1, 3, 5]

## filterNotNull() ##

过滤非空元素

fun main(args: Array<String>) { 
        val iterable = listOf(1, null, 3, null, 5)
    
        println(iterable.filterNotNull())
    }

[1, 3, 5]

## find() ##

第一个符合条件的元素，等价于 `firstOrNull()`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.find {  it % 2 == 0 })
        println(iterable.find {  it % 6 == 0 })
    }

2
    null

## findLast() ##

从后往前第一个符合条件的元素，等价于`lastOrNull()`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.findLast {  it % 2 == 0 })
        println(iterable.findLast {  it % 6 == 0 })
    }

4
    null

## first() ##

第一个符合条件的元素，找不到返回异常

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.first())
        println(iterable.first {  it % 2 == 0 })
        println(iterable.first {  it % 6 == 0 })
    }

1
    2
    Exception in thread "main" java.util.NoSuchElementException: No element matching predicate was found.

## firstOrNull() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.firstOrNull())
        println(iterable.firstOrNull {  it % 2 == 0 })
        println(iterable.firstOrNull {  it % 6 == 0 })
    }

1
    2
    null

## last() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.last())
        println(iterable.last {  it % 2 == 0 })
        println(iterable.last {  it % 6 == 0 })
    }

5
    4
    Exception in thread "main" java.util.NoSuchElementException: No element matching predicate was found.

## lastOrNull() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.lastOrNull())
        println(iterable.lastOrNull {  it % 2 == 0 })
        println(iterable.lastOrNull {  it % 6 == 0 })
    }

5
    4
    null

## flatMap() ##

连接多个Iterable

fun main(args: Array<String>) { 
        val iterable: Iterable<Iterable<Int>> = listOf(
            listOf(1, 2, 3),
            listOf(4, 5, 6),
            listOf(7, 8, 9)
        )
    
        println(iterable.flatMap {  it })
    }

[1, 2, 3, 4, 5, 6, 7, 8, 9]

## flatten() ##

拍平子Iterable

fun main(args: Array<String>) { 
        val iterable: Iterable<Iterable<Int>> = listOf(
            listOf(1, 2, 3),
            listOf(4, 5, 6),
            listOf(7, 8, 9)
        )
    
        println(iterable.flatten())
    }

[1, 2, 3, 4, 5, 6, 7, 8, 9]

## fold() ##

对每个元素逐个执行lambda运算，运算结果作为下次运算的输入。  
第一个参数为启动输入

fun main(args: Array<String>) { 
        val iterable = listOf("a", "b", "c")
    
        println(iterable.fold("Z", {  buf, value -> buf + value }))
    }

Zabc

## forEach() ##

循环遍历

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        iterable.forEach {  println(it) }
    }

1
    2
    3

## groupBy() ##

根据条件分组

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5, 6, 7)
    
        val result1: Map<String, List<Int>> =
            iterable.groupBy {  if (it % 2 == 0) "偶数" else "奇数" }
    
        println(result1)
    
    
        val result2: Map<String, List<String>> =
            iterable.groupBy(
                {  if (it % 2 == 0) "偶数" else "奇数" },
                {  "<$it>"}
            )
    
        println(result2)
    }

{奇数=[1, 3, 5, 7], 偶数=[2, 4, 6]}
    {奇数=[<1>, <3>, <5>, <7>], 偶数=[<2>, <4>, <6>]}

## indexOfFirst() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.indexOfFirst {  it % 2 == 0 })
    }

## indextOfLast() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.indexOfLast {  it % 2 == 0 })
    }

## intersect() ##

去重后返回`Set`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
        val other = listOf(2, 3, 5, 2)
    
        val result: Set<Int> = iterable.intersect(other)
    
        println(result)
    }

[2, 3, 5]

## joinTo() ##

将集合以字符串输出，可以通过`Appendable`指定元素的连接格式，默认是半角逗号

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
        val buffer: Appendable = StringBuilder()
    
        iterable.joinTo(buffer)
    
        println(buffer)
    }

1, 2, 3, 4, 5

可以通过更多参数，指定更复杂的连接格式

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
        val buffer: Appendable = StringBuilder()
    
        iterable.joinTo(
            buffer = buffer,
            separator = " - ",
            prefix = "{",
            postfix = "}",
            limit = 3,
            truncated = "(ry",
            transform = {  "<$it>" }
        )
    
        println(buffer)
    }

{<1> - <2> - <3> - (ry}

<table> 
 <thead> 
  <tr> 
   <th align="left">参数</th> 
   <th align="left">说明</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">separator</td> 
   <td align="left">分隔符</td> 
   <td align="left">,</td> 
  </tr> 
  <tr> 
   <td align="left">prefix</td> 
   <td align="left">字符串前缀</td> 
   <td align="left">“”</td> 
  </tr> 
  <tr> 
   <td align="left">postfix</td> 
   <td align="left">字符串后缀</td> 
   <td align="left">“”</td> 
  </tr> 
  <tr> 
   <td align="left">limit</td> 
   <td align="left">连接元素数量</td> 
   <td align="left">-1</td> 
  </tr> 
  <tr> 
   <td align="left">truncated</td> 
   <td align="left">省略元素表示</td> 
   <td align="left">…</td> 
  </tr> 
  <tr> 
   <td align="left">transform</td> 
   <td align="left">各元素的格式</td> 
   <td align="left">null</td> 
  </tr> 
 </tbody> 
</table>

## joinToString() ##

等价于`jointTo()`使用默认`Appendable`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.joinToString())
    }

1, 2, 3, 4, 5

## map() ##

对每个元素做映射，转成新的集合

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.map {  it * 10 })
    }

[10, 20, 30, 40, 50]

## mapNotNull() ##

lambda返回null时丢弃

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.mapNotNull {  if (it % 2 == 0) it else null })
    }

[2, 4]

## max(), min() ##

获取最大、最小值，集合需要实现`Comparable`接口

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.max())
        println(iterable.min())
    }

5
    1

## maxBy(), minBy() ##

根据lambda计算最大、最小值

fun main(args: Array<String>) { 
        val iterable = listOf("zz", "yyy", "xxxx")
    
        println(iterable.maxBy {  it.length })
        println(iterable.minBy {  it.length })
    }

xxxx
    zz

## maxWith(), minWith() ##

通过`Comparator`指定比较的方法

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.maxWith(Comparator {  a, b -> b - a }))
        println(iterable.minWith(Comparator {  a, b -> b - a }))
    }

1
    5

## minus() ##

运算符重载，集合补集

fun main(args: Array<String>) { 
        val iterable1 = listOf(1, 1, 2, 2, 3, 4, 5)
        val iterable2 = listOf(2, 4, 5);
    
        println(iterable1.minus(1))
        println(iterable1.minus(iterable2))
        println(iterable1 - iterable2)
    }

[1, 2, 2, 3, 4, 5]
    [1, 1, 3]
    [1, 1, 3]

## plus() ##

运算符重载，集合并集

fun main(args: Array<String>) { 
        val iterable1 = listOf(1, 2, 3)
        val iterable2 = listOf(3, 5)
    
        println(iterable1.plus(6))
        println(iterable1.plus(iterable2))
        println(iterable1 + iterable2)
    }

[1, 2, 3, 6]
    [1, 2, 3, 3, 5]
    [1, 2, 3, 3, 5]

## none() ##

不包含指定条件元素时，返回`true`

fun main(args: Array<String>) { 
        val iterable1 = listOf(1, 2, 3)
        val iterable2 = listOf<Int>();
    
        println(iterable1.none())
        println(iterable2.none())
    
        println(iterable1.none { it < 2})
        println(iterable1.none { it < 1})
    }

false
    true
    false
    true

## partition() ##

按条件分割后返回`Pair`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        val pair: Pair<Iterable<Int>, Iterable<Int>> = iterable.partition {  it % 2 == 0 }
    
        println(pair)
    }

([2, 4], [1, 3, 5])

## reduce() ##

类似`fold()`，区别是用元素的第一个元素做起始值

fun main(args: Array<String>) { 
        val iterable = listOf("a", "b", "c")
    
        println(iterable.reduce { tmp, value ->
            println("tmp=$tmp, value=$value")
            tmp + ":" + value
        })
    }

tmp=a, value=b
    tmp=a:b, value=c
    a:b:c

## requireNoNulls() ##

确保不存在`null`元素，否则异常

fun main(args: Array<String>) { 
        val iterable = listOf("a", "b", null, "c")
    
        println(iterable.requireNoNulls())
    }

Exception in thread "main" java.lang.IllegalArgumentException: null element found in [a, b, null, c].
        at kotlin.collections.CollectionsKt___CollectionsKt.requireNoNulls(_Collections.kt:1583)

## reversed() ##

逆序

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4)
    
        println(iterable.reversed())
    }

[4, 3, 2, 1]

## single() ##

获取符合条件的唯一的元素

fun main(args: Array<String>) { 
        val iterable1 = listOf(9)
        val iterable2 = listOf(1, 2, 3, 4)
    
        println(iterable1.single())
        println(iterable2.single { it == 3})
    }

9
    3

当两个以上符合条件时，抛出异常

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4)
    
        println(iterable.single())

Exception in thread "main" java.lang.IllegalArgumentException: Collection has more than one element.
        at kotlin.collections.CollectionsKt___CollectionsKt.single(_Collections.kt:487)

## singleOrNull() ##

与`single()`类似，不会抛出异常

fun main(args: Array<String>) { 
        val iterable1 = listOf(9)
        val iterable2 = listOf(1, 2, 3, 4)
    
    
        println(iterable1.singleOrNull())
    
        println(iterable2.singleOrNull { it == 4})
        println(iterable2.singleOrNull())
    }

9
    4
    null

## sorted(), sortedDescending() ##

排序（正序、倒序）

fun main(args: Array<String>) { 
        val iterable = listOf(3, 1, 2, 4)
    
        println(iterable.sorted())
        println(iterable.sortedDescending())
    }

[1, 2, 3, 4]
    [4, 3, 2, 1]

## sortedBy(), sortedByDescending() ##

根据lambda进行排序

fun main(args: Array<String>) { 
        val iterable = listOf(3, 1, 2, 4)
    
        println(iterable.sortedBy {  it * -1 })
        println(iterable.sortedByDescending {  it * -1 })
    }

[4, 3, 2, 1]
    [1, 2, 3, 4]

## sortedWith() ##

需要实现`Comparator`接口

fun main(args: Array<String>) { 
        val iterable = listOf(3, 1, 2, 4)
    
        println(iterable.sortedWith(Comparator {  left, right -> right - left }))
    }

[4, 3, 2, 1]

ソート方法を Comparator で実装して渡す。

## subtract() ##

使用`Iterable`过滤

fun main(args: Array<String>) { 
        val iterable1 = listOf(1, 1, 2, 2, 3, 4, 5)
        val iterable2 = listOf(2, 3, 4)
    
        println(iterable1.subtract(iterable2))
    }

[1, 5]

## sum() ##

求和

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.sum())
    }

## sumBy() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.sumBy {  it * 10 })
    }

## sumByDouble() ##

求和返回Double型

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        println(iterable.sumByDouble {  it * 1.5 })
    }

9.0

## take() ##

截取前n个元素

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.take(3))
    }

[1, 2, 3]

## takeWhile() ##

条件截取

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        println(iterable.takeWhile {  it < 5 })

[1, 2, 3, 4]

## toCollection() ##

向指定`MutableCollection`中追加元素

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        val result: MutableCollection<Int> = mutableListOf(9)
    
        iterable.toCollection(result)
    
        println(result)
    }

[9, 1, 2, 3]

## toHashSet() ##

转`HashSet`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 1, 2, 2, 2, 3, 3)
    
        val result: HashSet<Int> = iterable.toHashSet()
    
        println(result)
    }

[1, 2, 3]

## toList() ##

转`List`

fun main(args: Array<String>) { 
        val iterable = setOf(1, 2, 3)
    
        val list: List<Int> = iterable.toList()
    
        println(list)
    }

[1, 2, 3]

## toMap() ##

转`Map`

fun main(args: Array<String>) { 
        val iterable = listOf("foo" to "FOO", "bar" to "BAR")
    
        val map: Map<String, String> = iterable.toMap()
    
        println(map)
    
        val result = mutableMapOf("fizz" to "FIZZ")
    
        iterable.toMap(result)
    
        println(result)
    }

{foo=FOO, bar=BAR}
    {fizz=FIZZ, foo=FOO, bar=BAR}

## toMutableList() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3)
    
        val result: MutableList<Int> = iterable.toMutableList()
    
        println(result)
    }

[1, 2, 3]

## toMutableSet() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 1, 2, 3, 3)
    
        val result: MutableSet<Int> = iterable.toMutableSet()
    
        println(result)
    }

[1, 2, 3]

## toSet() ##

fun main(args: Array<String>) { 
        val iterable = listOf(1, 1, 2, 3, 3)
    
        val result: Set<Int> = iterable.toSet()
    
        println(result)
    }

[1, 2, 3]

## toSortedSet() ##

fun main(args: Array<String>) { 
        val iterable = listOf(3, 1, 2, 3, 1, 4)
    
        val result: SortedSet<Int> = iterable.toSortedSet()
    
        println(result)
    }

[1, 2, 3, 4]

## union() ##

并集

fun main(args: Array<String>) { 
        val iterable1 = listOf(1, 2, 3, 4)
        val iterable2 = listOf(2, 4, 5, 6)
    
        val result: Set<Int> = iterable1.union(iterable2)
    
        println(result)
    }

[1, 2, 3, 4, 5, 6]

## unzip() ##

`List<Pair<T, U>>` 变 `Pair<List<T>, List<U>>`

fun main(args: Array<String>) { 
        val iterable = listOf("one" to 1, "two" to 2, "three" to 3)
    
        val result: Pair<List<String>, List<Int>> = iterable.unzip()
    
        println(result)
    }

([one, two, three], [1, 2, 3])

## withIndex() ##

转为`Iterable<IndexedValue<T>>`

fun main(args: Array<String>) { 
        val iterable = listOf(1, 2, 3, 4, 5)
    
        val result: Iterable<IndexedValue<Int>> = iterable.withIndex()
    
        result.forEach {  println("index=${ it.index}, value=${ it.value}") }
    }

index=0, value=1
    index=1, value=2
    index=2, value=3
    index=3, value=4
    index=4, value=5

## zip() ##

两个集合，元素一一组`Pair`返回`List`

fun main(args: Array<String>) { 
        val iterable1 = listOf(1, 2, 3)
    
        val iterable2 = listOf("one", "two", "three", "four")
        val result1: List<Pair<Int, String>> = iterable1.zip(iterable2)
        println(result1)
    
        val array = arrayOf(1.1, 2.2)
        val result2: List<Pair<Int, Double>> = iterable1.zip(array)
        println(result2)
    }

[(1, one), (2, two), (3, three)]
    [(1, 1.1), (2, 2.2)]

两个集合`size`不等时，按照较少`size`的集合`zip`

fun main(args: Array<String>) { 
        val iterable1 = listOf(1, 2, 3)
    
        val iterable2 = listOf("one", "two", "three", "four")
        val result1: List<String> = iterable1.zip(iterable2, { a, b -> "$b($a)"})
        println(result1)
    
        val array = arrayOf(1.1, 2.2)
        val result2: List<Int> = iterable1.zip(array, { a, b -> (a + b*10).toInt()})
        println(result2)
    }

[one(1), two(2), three(3)]
    [12, 24]

## containsAll() ##

判断子集

fun main(args: Array<String>) { 
        val collection1 = listOf(1, 2, 3, 4)
        val collection2 = listOf(2, 3)
        val collection3 = listOf(4, 5)
    
        println(collection1.containsAll(collection2))
        println(collection1.containsAll(collection3))
    }

true
    false

# Collection #

--------------------

## isEmpty(), isNotEmpty() ##

fun main(args: Array<String>) { 
        val collection1 = listOf(1, 2, 3, 4)
        val collection2 = listOf<Int>()
    
        println(collection1.isEmpty())
        println(collection2.isEmpty())
    
        println(collection1.isNotEmpty())
        println(collection2.isNotEmpty())
    }

false
    true
    true
    false

## orEmpty() ##

`null`则返回空集合，否则返回自身

fun main(args: Array<String>) { 
        val collection1 = listOf(1, 2, 3, 4)
        val collection2: Collection<Int>? = null
    
        println(collection1.orEmpty())
        println(collection2.orEmpty())
    }

[1, 2, 3, 4]
    []

## to\*\*\*Array() ##

转成各种类型的Array，Boolean, Byte, Char, Double, Float, Int, Long, Short等

fun main(args: Array<String>) { 
        val collection = listOf(1, 2, 3, 4)
    
        val array: IntArray = collection.toIntArray()
    
        array.forEach {  println(it) }
    }

1
    2
    3
    4

## toTypedArray() ##

转`Array<T>`

fun main(args: Array<String>) { 
        val collection = listOf(1, 2, 3, 4)
    
        val array: Array<Int> = collection.toTypedArray()
    
        array.forEach {  println(it) }
    }

1
    2
    3
    4

# List #

--------------------

## asReversed() ##

逆序。与`reversed()` 类似，但是不改变原集合类型。  
比如`MutableList`仍然返回 `MutableList`，而`reversed()` 会返回 `List`

fun main(args: Array<String>) { 
        val list = mutableListOf(1, 2, 3)
    
        println("[before] list = $list")
    
        val asReversed = list.asReversed()
    
        println("[after asReversed] list = $list")
        println("[after asReversed] asReversed = $asReversed")
    
        list += 9
        asReversed += 99
    
        println("[after modify] list = $list")
        println("[after modify] asReversed = $asReversed")
    }

[before] list = [1, 2, 3]
    [after asReversed] list = [1, 2, 3]
    [after asReversed] asReversed = [3, 2, 1]
    [after modify] list = [99, 1, 2, 3, 9]
    [after modify] asReversed = [9, 3, 2, 1, 99]

## binarySearch() ##

二分查找，`fromIndex`、`toIndex`指定查找范围

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 2, 3, 3, 3)
    
        println(list.binarySearch(3))
        println(list.binarySearch(9))
        println(list.binarySearch(element = 3, fromIndex = 0, toIndex = 2))
        println(list.binarySearch(element = 3, comparator = Comparator {  a, b -> a - b }))
    }

4
    -7
    -3
    4

## binarySearchBy() ##

将元素转成`selector`，然后与第一个参数比较，返回命中的结果index

fun main(args: Array<String>) { 
        val list = listOf("I", "he", "her", "you")
    
        println(list.binarySearchBy("Thank you", selector = {  "Thank $it" }))
    }

## component\*() ##

结构后的元素。没啥意义

fun main(args: Array<String>) { 
        val list = listOf("one", "two", "three", "four", "five")
    
        println(list.component1())
        println(list.component2())
        println(list.component3())
        println(list.component4())
        println(list.component5())
    }

one
    two
    three
    four
    five

## dropLast() ##

从尾部删除

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 3, 4, 5)
    
        println(list.dropLast(2))
    }

[1, 2, 3]

## dropLastWhile() ##

从尾部开始根据lambda删除

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 3, 4, 5)
    
        println(list.dropLastWhile {  it > 2 })
    }

[1, 2]

## foldRight() ##

从尾部开始执行`fold()`

fun main(args: Array<String>) { 
        val list = listOf("a", "b", "c")
    
        println(list.foldRight("Z", {  value, buf -> buf + value }))
    }

Zcba

## getOrElse() ##

获取指定值或默认值

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 3)
    
        println(list.getOrElse(0, {  9 }))
        println(list.getOrElse(4, {  9 }))
    }

1
    9

## getOrNull() ##

指定值或`null`

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 3)
    
        println(list.getOrNull(0))
        println(list.getOrNull(4))
    }

1
    null

## reduceRight() ##

尾部开始`reduce()`

fun main(args: Array<String>) { 
        val list = listOf("a", "b", "c")
    
        println(list.reduceRight {  value, tmp ->
            println("value=$value, tmp=$tmp")
            tmp + ":" + value
        })
    }

value=b, tmp=c
    value=a, tmp=c:b
    c:b:a

## slice() ##

切片

fun main(args: Array<String>) { 
        val list = listOf("0:one", "1:two", "2:three", "3:four", "4:five")
        println(list.slice(2..4))
    
        val indices = listOf(1, 3, 4)
        println(list.slice(indices))
    }

[2:three, 3:four, 4:five]
    [1:two, 3:four, 4:five]

## takeLast() ##

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 3, 4, 5)
    
        println(list.takeLast(2))
    }

[4, 5]

## takeLastWhile() ##

fun main(args: Array<String>) { 
        val list = listOf(1, 2, 3, 4, 5)
    
        println(list.takeLastWhile {  it > 2 })
    }

[3, 4, 5]

# MutableIterable #

--------------------

## removeAll() ##

fun main(args: Array<String>) { 
        val mutableIterable = mutableListOf(1, 2, 3, 1, 2, 3)
    
        mutableIterable.removeAll {  it == 3 }
    
        println(mutableIterable)
    }

[1, 2, 1, 2]

## retainAll() ##

保留

fun main(args: Array<String>) { 
        val mutableIterable = mutableListOf(1, 2, 3, 1, 2, 3)
    
        mutableIterable.retainAll {  it == 3 }
    
        println(mutableIterable)
    }

[3, 3]

# MutableCollection #

--------------------

## addAll() ##

fun main(args: Array<String>) { 
        val mutableCollection = mutableListOf(1, 2, 3)
        val iterable = listOf(7, 8, 9)
    
        mutableCollection.addAll(iterable)
    
        println(mutableCollection)
    }

[1, 2, 3, 7, 8, 9]

## minusAssign() ##

操作符重载 `-=`

fun main(args: Array<String>) { 
        val mutableCollection = mutableListOf(1, 2, 3, 4, 5)
        val iterable = listOf(2, 4)
    
        mutableCollection.minusAssign(iterable)
        println(mutableCollection)
    
        mutableCollection -= 5
        println(mutableCollection)
    }

[1, 3, 5]
    [1, 3]

## plusAssign() ##

操作符重载 `+=`

fun main(args: Array<String>) { 
        val mutableCollection = mutableListOf(1, 2, 3)
        val iterable = listOf(7, 8)
    
        mutableCollection.plusAssign(iterable)
        println(mutableCollection)
    
        mutableCollection += 9
        println(mutableCollection)
    }

[1, 2, 3, 7, 8]
    [1, 2, 3, 7, 8, 9]

## remove() ##

fun main(args: Array<String>) { 
        val mutableCollection = mutableListOf(1, 2, 3)
    
        mutableCollection.remove(2)
    
        println(mutableCollection)
    }

[1, 3]

# MutableList #

--------------------

## reverse() ##

逆序

fun main(args: Array<String>) { 
        val mutableList = mutableListOf(1, 2, 3)
    
        mutableList.reverse()
    
        println(mutableList)
    }

[3, 2, 1]

## sort(), sortDescending() ##

fun main(args: Array<String>) { 
        val mutableList = mutableListOf(3, 1, 2)
    
        mutableList.sort()
        println(mutableList)
    
        mutableList.sortDescending()
        println(mutableList)
    }

[1, 2, 3]
    [3, 2, 1]

## sortBy(), sortByDescending() ##

fun main(args: Array<String>) { 
        val mutableList = mutableListOf("aaa", "bb", "c")
    
        mutableList.sortBy {  it.length }
        println(mutableList)
    
        mutableList.sortByDescending {  it.length }
        println(mutableList)
    }

[c, bb, aaa]
    [aaa, bb, c]

## sortWith() ##

fun main(args: Array<String>) { 
        val mutableList = mutableListOf(2, 3, 1)
    
        mutableList.sortWith(Comparator {  a, b ->  b - a})
        println(mutableList)
    }

[3, 2, 1]

# Map #

--------------------

所有`Entry`满足条件

## all() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.all {  it.key is String })
        println(map.all {  it.key.contains("o") })
    }

true
    false

## any() ##

任意`Entry`满足条件

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.any {  it.key.contains("o") })
        println(map.any {  it.key.isEmpty() })
    }

true
    false

## contains() ##

判断是否包含指定key， 等同`containsKey()`

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.contains("one"))
        println(map.contains("ONE"))
    }

true
    false

## containsKey() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.containsKey("one"))
        println(map.containsKey("ONE"))
    }

true
    false

## containsValue() ##

是否包含指定value

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.containsValue("one"))
        println(map.containsValue("ONE"))
    }

false
    true

## count() ##

符合条件的数量

fun main(args: Array<String>) {
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.count())
        println(map.count { it.key.contains("t") })
    }

3
    2

## filter(), filterNot() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.filter {  it.key.contains("t") })
        println(map.filterNot {  it.key.contains("t") })
    }

{two=TWO, three=THREE}
    {one=ONE}

## filterKeys(), filterValues() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.filterKeys {  key -> key.contains("o") })
        println(map.filterValues {  value -> value.contains("T") })
    }

{one=ONE, two=TWO}
    {two=TWO, three=THREE}

## flatMap() ##

按照lambda打平返回`List`

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.flatMap {  listOf(it.key, it.value) })
    }

[one, ONE, two, TWO, three, THREE]

## forEach() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        map.forEach {  println("key=${ it.key}, value=${ it.value}") }
    }

key=one, value=ONE
    key=two, value=TWO
    key=three, value=THREE

## getOrElse() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.getOrElse("one", { "DEFAULT"}))
        println(map.getOrElse("nine", { "DEFAULT"}))
    }

ONE
    DEFAULT

## isEmpty(), isNotEmpty() ##

fun main(args: Array<String>) { 
        val map = mapOf<String, String>()
    
        println(map.isEmpty())
        println(map.isNotEmpty())
    }

true
    false

## none() ##

fun main(args: Array<String>) { 
        val map1 = mapOf("one" to "ONE")
        val map2 = mapOf<String, String>()
    
        println(map1.none())
        println(map2.none())
    
        println(map1.none { it.key == "two"})
    }

false
    true
    true

## orEmpty() ##

fun main(args: Array<String>) { 
        val map1 = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
        val map2: Map<String, String>? = null
    
        println(map1.orEmpty())
        println(map2.orEmpty())
    }

{one=ONE, two=TWO, three=THREE}
    {}

## map(), mapNotNull() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.map {  if (it.key == "two") null else "${ it.key}=${ it.value}" })
        println(map.mapNotNull {  if (it.key == "two") null else "${ it.key}=${ it.value}" })
    }

[one=ONE, null, three=THREE]
    [one=ONE, three=THREE]

## mapKeys(), mapValues() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.mapKeys {  "<${ it.key}>" })
        println(map.mapValues {  "<${ it.value}>" })
    }

{<one>=ONE, <two>=TWO, <three>=THREE}
    {one=<ONE>, two=<TWO>, three=<THREE>}

## maxBy(), minBy() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.maxBy {  it.key })
        println(map.minBy {  it.key })

two=TWO
    one=ONE

## maxWith(), minWith() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        val comparator = Comparator<Map.Entry<String, String>> {  a, b -> a.key.compareTo(b.key) }
    
        println(map.maxWith(comparator))
        println(map.minWith(comparator))
    }

two=TWO
    one=ONE

## plus() ##

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(map.plus(mapOf("four" to "FOUR")))
        println(map.plus("five" to "FIVE"))
        println(map.plus(listOf("six" to "SIX")))
    
        println(map + ("seven" to "SEVEN"))
    }

{one=ONE, two=TWO, three=THREE, four=FOUR}
    {one=ONE, two=TWO, three=THREE, five=FIVE}
    {one=ONE, two=TWO, three=THREE, six=SIX}
    {one=ONE, two=TWO, three=THREE, seven=SEVEN}

## toList() ##

`Map<K, V>` 转 `List<Pair<K, V>>`

fun main(args: Array<String>) { 
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
        val list: List<Pair<String, String>> = map.toList()
    
        println(list)
    }

[(one, ONE), (two, TWO), (three, THREE)]

## toProperties() ##

转成`java.util.Properties`

fun main(args: Array<String>) {
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
        val properties: Properties = map.toProperties()
    
        println(properties)
    }

{two=TWO, one=ONE, three=THREE}

## toSortedMap() ##

转成`java.util.SortedMap`

fun main(args: Array<String>) {
        val map = mapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
        val sortedMap: SortedMap<String, String> = map.toSortedMap()
    
        println(sortedMap)
    }

{one=ONE, three=THREE, two=TWO}

# MutableMap #

--------------------

## getOrPut ##

获取指定值不存在时创建默认值，并将默认值插入Map

fun main(args: Array<String>) { 
        val mutableMap = mutableMapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        println(mutableMap.getOrPut("one", { "DEFAULT"}))
        println(mutableMap)
        println(mutableMap.getOrPut("four", { "DEFAULT"}))
        println(mutableMap)
    }

ONE
    {one=ONE, two=TWO, three=THREE}
    DEFAULT
    {one=ONE, two=TWO, three=THREE, four=DEFAULT}

## putAll ##

fun main(args: Array<String>) { 
        val mutableMap = mutableMapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        mutableMap.putAll(mapOf("four" to "FOUR", "five" to "FIVE"))
        println(mutableMap)
    
        mutableMap.putAll(listOf("six" to "SIX"))
        println(mutableMap)

{one=ONE, two=TWO, three=THREE, four=FOUR, five=FIVE}
    {one=ONE, two=TWO, three=THREE, four=FOUR, five=FIVE, six=SIX}

## plusAssign ##

`+=`的运算符重载，同`putAll()`

fun main(args: Array<String>) { 
        val mutableMap = mutableMapOf("one" to "ONE", "two" to "TWO", "three" to "THREE")
    
        mutableMap.plusAssign(mapOf("four" to "FOUR"))
        mutableMap.plusAssign("five" to "FIVE")
        mutableMap.plusAssign(listOf("six" to "SIX"))
    
        mutableMap += "seven" to "SEVEN"
    
        println(mutableMap)
    }

{one=ONE, two=TWO, three=THREE, four=FOUR, five=FIVE, six=SIX, seven=SEVEN}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh_size_16_color_FFFFFF_t_70]: /images/20230208/ac3bb528cea74a99b8b9dc634dd568b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh_size_16_color_FFFFFF_t_70 1]: /images/20230208/39ef4a58752145d7b18baa0f7d95b5b7.png