6.4 kotlin集合类型对比分析

集合类型 Collection

Kotlin本身就提供了几组非常良好的原生集合类型供你使用,分为如下几种：

Collection

代表了一组元素的通用集合。我们可以通过各种函数来访问集合,如返回集合大小、是否为空、是否包含某个元素或一组元素。

MutableCollection

支持添加和移除自身元素的 Collection，它提供了额外的功能，如add、 remove或 clear等。

List

List代表了一组有序元素的集合。因为是排序了的,我们可以通过位置请求对应的元素,使用get函数或快捷的下标中括号方法。

Mutable list

Mutablelist顾名思义，是一个支持添加和移除元素的List。

Set

是个无序的，但其中元素并不重复的集合。

MutableSet:

一个支持添加和删除元素的set。

Map

键值对( Key-value Pair)的集合，其中的键具有唯一性，也就是说一个map里不能有两个一样的键(key)

MutableMap

一个支持添加和移除元素的Map

集合类型常用操作

any:

只要其中一个元素满足判定条件，返回true。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.any { it % 2 == 0 })
    println(mList.any { it > 8 })

结果:

true
false

all

如果所有元素满足条件，返回true。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.all { it < 8 })
    println(mList.all { it % 2 == 0 })

结果:

true
false

count

返回匹配条件的元素数目。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.count { it % 2 == 0 })

结果：3

fold

提供一个初始值，并描述从第一个到最后一个元素如何依次与这个初始值计算的操作。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.fold(0) { total, next -> total + next })
    println(mList.fold(1) { total, next -> total * next })

结果：

21
720

foldright

与fold一样，但顺序是从最后一个元素到第一个。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.foldRight(0) { total, next -> total + next })
    println(mList.foldRight(1) { total, next -> total * next })

结果：

21
720

foreach

对每个元素执行指定的操作。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    mList.forEach { println(it) }

结果：

1
2
3
4
5
6

forEachIndexed

与 foreach相似，但可以获取元素的索引。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    mList.forEachIndexed { index: Int, value: Int ->
        println("位置 $index 的元素为$value")
    }

结果

位置 1 的元素为2
位置 2 的元素为3
位置 3 的元素为4
位置 4 的元素为5
位置 5 的元素为6

max

获取最大的元素，如果没有元素则返回null

   val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.max())

结果：6

maxBy

给定函数操作后产生最大值的那个元素，没有元素则返回null.

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.maxBy { it * 7 })

结果：6

min

返回最小的元素,没有元素则返回null

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.min())

结果：1

minBy

给定函数操作后产生最小值的那个元素，没有元素则返回null

    val mList = listOf(1, 2, 3, 4, 5, 6)
    //返回负值最小的那个元素
    println(mList.minBy { it * 7 })

结果：1

none

如果没有元素满足条件返回true

    val mList = listOf(1, 2, 3, 4, 5, 6)
    //没有元素可以整除8
    println(mList.none { it % 8 == 0 })

结果：true

reduce

与fold相似,但不需要初始值，描述从第一个到最后一个元素如何依次计算的操作。

val mList = listOf(1, 2, 3, 4, 5, 6)
println(mList.reduce { totol, next -> totol + next })
println(mList.reduce { totol, next -> totol * next })

结果:

21
720

reduceRight

与 reduce类似,但顺序是从最后一个元素开始。

val mList = listOf(1, 2, 3, 4, 5, 6)
println(mList.reduceRight { totol, next -> totol + next })
println(mList.reduceRight { totol, next -> totol * next })

结果:

21
720

sumBy

返回经过处理过的元素的和。所有元素乘以2后的和

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.sumBy { it * 2 })

结果：42

drop

把头n个元素丢弃后的所有元素返回

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.drop(3))

结果：[4, 5, 6]

dropWhile

把头几个满足条件的元素丢弃后返回。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.dropWhile { it < 3 })

结果：[3, 4, 5, 6]

dropLast

把后n个元素丢弃后返回。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.dropLast(3))

结果：[1, 2, 3]

dropLastWhile

把最后几个满足条件的元素丢弃后返回。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.dropLastWhile { it > 5 })

结果：[1, 2, 3, 4, 5]

filter

返回满足条件的所有元素。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.filter { it > 5 })

结果: [6]

filterNot

返回不满足条件的所有元素

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.filterNot { it > 5 })

结果: [1, 2, 3, 4, 5]

filterNotNull

返回所有非null元素。

    val mList = listOf(1, 2, 3, 4, 5, 6, null)
    println(mList.filterNotNull())

结果：[1, 2, 3, 4, 5, 6]

slice:切割,按指定索引或索引范围内的元素。

    val mList = listOf(1, 2, 3, 4, 5, 6, null)
    println(mList.slice(listOf(0, 5, 6)))
    println(mList.slice(1..6))

结果:

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

take

返回头n个元素。与dop相对。

    val mList = listOf(1, 2, 3, 4, 5, 6, null)
    println(mList.take(3))

结果: [1, 2, 3]

takeLast

返回从尾倒数n个元素,与 droplast相对。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.takeLast(3))

结果：[4, 5, 6]

takeWhile

返回满足条件的头n个元素。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.takeWhile { it < 4 })

结果：[1, 2, 3]

takeLastWhile

从后往前数返回满足条件的头n个元素。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.takeLastWhile { it > 4 })

结果：[5, 6]
结果:[0.2.6,12,20.30이

contains

如果找到此元素返回true。

elementAt

返回指定索引处的元素,如果索引不在集合的索引范围内,则抛索引越界异常错误。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.elementAt(1))

结果: 2

reversed

返回颠倒顺序的所有元素。

    val mList = listOf(1, 2, 3, 4, 5, 6)
    println(mList.reversed())

结果：[6, 5, 4, 3, 2, 1]

sorted

返回升序排列后的所有元素

    val mList = listOf(1, 7, 3, 2, 4, 6)
    println(mList.sorted())

结果：[1, 2, 3, 4, 6, 7]

sortedDescending

返回降序排列后的所有元素

    val mList = listOf(1, 7, 3, 2, 4, 6)
    println(mList.sortedDescending())

结果：[7, 6, 4, 3, 2, 1]