Osheep

时光不回头,当下最重要。

使用Kotlin开发Android--常见的集合函数运用

上一篇:kotlin常见的fun函数定义
下一篇:If、When、Loop的运用

Array为例

今天一起来学习一下Kotlin中,常见的集合函数的运用。我们今天以Array数组的操作为例,先来直接看一下代码~

/**
 * 数组详解 2017/4/1 11:10
 */
class TestArray {

    private var _array:Array<Int>

    /**
     * 初始化方法 2017/4/1 11:10
     */
    init {
        _array = arrayOf(1, 3, 2, 3, 4)
    }

    /**
     * 除去重复元素,返回List列表 2017/4/1 11:16
     */
    fun distinct() {
        println("TestArray.distinct()   ->   " + this._array.distinct())
    }

    /**
     * 追加元素 2017/4/1 11:21
     */
    fun plus() {
        println("TestArray.plus()   ->   " + this._array.plus(arrayOf(5, 6)).toList())
    }

    /**
     * 倒序 2017/4/1 11:25
     */
    fun reverse() {
        println("TestArray.reverse()   ->   " + this._array.reversed())
    }

    /**
     * 切片 2017/4/1 11:28
     */
    fun slice() {
        println("TestArray.slice()   ->   " + this._array.slice(IntRange(0, 2)))
    }

    /**
     * 切片 2017/4/1 11:28
     */
    fun sort() {
        this._array.sort()
        println("TestArray.sort()   ->   " + this._array.toList())
    }

    /**
     * 对象排序 2017/4/1 11:40
     */
    fun sortWith() {
        var array1 = ArrayEntity()
        array1.id = 2

        var array2 = ArrayEntity()
        array2.id = 1

        var array3 = ArrayEntity()
        array3.id = 3

        var array = arrayOf(array1, array2, array3)
        array.sortWith(Comparator { o1, o2 -> o2.id.compareTo(o1.id) })
        for (entity in array)
            println("TestArray.sortWith()   ->   " + entity.id)
    }

    /**
     * 如果至少有一个元素与指定条件相符,则返回true 2017/4/1 13:49
     */
    fun any() {
        println("TestArray.any()   ->   " + this._array.any())
        var tmp:Array<Int> = arrayOf()
        println("TestArray.any()   ->   " + tmp.any())
    }

    /**
     * 判断是否有指定的元素存在,有就返回true 2017/4/1 13:52
     */
    fun contains() {
        println("TestArray.contains()   ->   " + this._array.contains(1))
    }

    /**
     * 删除前两位 2017/4/1 15:01
     */
    fun drop() {
        var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
        println("TestArray.drop()   ->   " + tmp.drop(2))

        // dropWhile  这个方法的意思是返回所有元素列表,但不包括第一个满足指定条件的元素。
        // 但看了里面的源代码,写得有点问题 2017/4/1 17:03
        // tmp.dropWhile { it > 3 }
    }

    /**
     * 删除后两位 2017/4/1 15:01
     */
    fun dropLast() {
        var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
        println("TestArray.dropLast()   ->   " + tmp.dropLast(2))
    }

    /**
     * 提取前两位元素返回 2017/4/2 17:48
     */
    fun take() {
        var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
        println("TestArray.take()   ->   " + tmp.take(2))
    }

    /**
     * 提取最后两位元素返回 2017/4/2 17:48
     */
    fun takeLast() {
        var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
        println("TestArray.takeLast()   ->   " + tmp.takeLast(2))
    }

    /**
     *过滤掉剩下条件为true的元素 2017/4/1 17:20
     */
    fun filter() {
        println("TestArray.filter()   ->   " + this._array.filter { it % 2 == 0 })
    }

    /**
     * 过滤掉剩下条件为true的元素,另一种写法 2017/4/1 17:20
     */
    fun filterTo() {
        var list = ArrayList<Int>()
        println("TestArray.filterTo()   ->   " + this._array.filterTo(list, { it % 2 == 0 }))
    }

    /**
     * 过滤掉条件为true的元素 2017/4/1 17:21
     */
    fun filterNotTo() {
        var list = ArrayList<Int>()
        println("TestArray.filterNotTo()   ->   " + this._array.filterNotTo(list, { it % 2 == 0 }))
    }

    /**
     * 返回所有元素列表,但不包括null元素 2017/4/1 17:25
     */
    fun filterNotNull() {
        println("TestArray.filterNotNull()   ->   " + this._array.filterNotNull())
    }

    /**
     * 根据指定索引,获取元素 2017/4/1 17:27
     */
    fun elementAt() {
        println("TestArray.elementAt()   ->   " + this._array.elementAt(2))
    }

    /**
     * 查找元素,可以判断是否存在该元素,没有的话返回null 2017/4/1 17:29
     */
    fun find() {
        println("TestArray.find()   ->   " + this._array.find { it == 3 })
    }

    /**
     * 遍历 2017/4/1 17:45
     */
    fun forEach() {
        println("TestArray.forEach()   ->   " + this._array.toList())
        this._array.forEach({
            println(it)
        })
    }

    /**
     * 对每一个元素操作后,返回一个新的列表 2017/4/2 17:46
     */
    fun map() {
        println("TestArray.forEach()   ->   " + this._array.map { it * 2 })
    }

    /**
     * 从第一元素到最后一个元素运算的累加,acc每一个元素累计后的值,i当前的元素 2017/4/2 17:53
     */
    fun reduce() {
        println("TestArray.reduce()   ->   " + this._array.reduce { acc, i -> acc + i })
    }

    /**
     * 返回最小的元素 2017/4/2 17:55
     */
    fun min() {
        println("TestArray.min()   ->   " + this._array.min())
    }

    /**
     * 返回最大的元素 2017/4/2 17:55
     */
    fun max() {
        println("TestArray.max()   ->   " + this._array.max())
    }

}

/**
 * 实体 2017/4/1 13:36
 */
class ArrayEntity {
    var id:Int = 0
    var name:String? = null
}

以上的操作基本上是最常见的集合函数运用,我们再来看下各个函数的描述,是我整合网上的资源的,如下:

集合

虽然,我们可以只使用Java集合,然而Kotlin提供了一套很好的本机接口:

Iterable :父类。任何类继承这个接口就表示可以遍历序列的元素。
MutableIterable :在迭代期间支持移除项目的迭代。
Collection :这个类表示元素的泛型集合。我们可以访问函数:返回集合尺寸、集合是否为空、包含一项或一组。由于集合是不可变的,这类集合的所有方法只能请求数据。
MutableCollection :支持添加和移除元素的Collection。它提供额外的函数,如:add、remove或clear等等。
List :或许这是最常用的集合。这表示有序的元素泛型集合。由于是有序的,我们可以用get函数,按照项目的位置请求项目。
MutableList :支持添加和移除元素的List。
Set :不支持重复元素的无序元素集合。
MutableSet :支持添加和移除元素的Set。
Map :key-value(键-值)对集合。在映射表(map)中key(键)是唯一的,就是说在一个映射表中不能有两对有相同的key。
MutableMap :支持添加和移除元素的Map。

1、 聚合操作

any
如果至少有一个元素与指定条件相符,则返回true。
val list = listOf(1, 2, 3, 4, 5, 6)
assertTrue(list.any { it % 2 == 0 })
assertFalse(list.any { it > 10 })

all
如果所有元素与指定条件相符,则返回true。
assertTrue(list.all { it < 10 })
assertFalse(list.all { it % 2 == 0 })

count
返回与指定条件相符的元素个数。
assertEquals(3, list.count { it % 2 == 0 })

fold
将对集合从第一个到最后一个元素的操作结果进行累加,并加上初始值。
assertEquals(25, list.fold(4) { total, next -> total + next })

foldRight
同fold,但是,是从最后一个元素到第一个元素。
assertEquals(25, list.foldRight(4) { total, next -> total + next })

forEach
对每个元素执行指定的操作。
list forEach { println(it) }

forEachIndexed
同forEach,不过同时还获得元素的索引。
list forEachIndexed { index, value
-> println(“position $index contains a $value”) }

max
返回最大元素。如果没有元素,则返回null。
assertEquals(6, list.max())

maxBy
返回使指定函数产生最大值的第一个元素。如果没有元素,则返回null。
// The element whose negative is greater
assertEquals(1, list.maxBy { -it })

min
返回最小元素,如果没有元素,则返回null。
assertEquals(1, list.min())

minBy
返回使指定函数产生最小值的第一个元素。如果没有元素,则返回null。
// The element whose negative is smaller
assertEquals(6, list.minBy { -it })

none
如果没有元素与指定条件相符,则返回true。
// No elements are divisible by 7
assertTrue(list.none { it % 7 == 0 })

reduce
同fold,但是不包括初始值。只是将对集合从第一个元素到最后一个元素的操作结果进行累加。
assertEquals(21, list.reduce { total, next -> total + next })


reduceRight
同reduce,但是,是从最后一个元素到第一个元素。
assertEquals(21, list.reduceRight { total, next -> total + next })

sumBy
返回集合中元素进转换函数产生值的总和。
assertEquals(3, list.sumBy { it % 2 })

2、 筛选操作

drop
返回所有元素列表,但不包括前N个元素。
assertEquals(listOf(5, 6), list.drop(4))

dropWhile
返回所有元素列表,但不包括第一个满足指定条件的元素。
assertEquals(listOf(3, 4, 5, 6), list.dropWhile { it < 3 })

dropLastWhile
返回所有元素列表,但不包括满足指定条件的最后一个元素。
assertEquals(listOf(1, 2, 3, 4), list.dropLastWhile { it > 4 })

filter
返回所有与指定条件相符的元素列表。
assertEquals(listOf(2, 4, 6), list.filter { it % 2 == 0 })

filterNot
返回与指定条件不符的所有元素列表。
assertEquals(listOf(1, 3, 5), list.filterNot { it % 2 == 0 })

filterNotNull
返回所有元素列表,但不包括null元素。
assertEquals(listOf(1, 2, 3, 4), listWithNull.filterNotNull())

slice
返回指定索引的元素列表。
assertEquals(listOf(2, 4, 5), list.slice(listOf(1, 3, 4)))

take
返回前N个元素列表。
assertEquals(listOf(1, 2), list.take(2))

takeLast
返回最后N个元素列表。
assertEquals(listOf(5, 6), list.takeLast(2))

takeWhile
返回满足指定条件第一个元素列表。
assertEquals(listOf(1, 2), list.takeWhile { it < 3 })

3、映射操作

flatMap
通过遍历每个元素创建一个新集合,最后,把所有集合整合到包含所有元素的唯一列表中。
assertEquals(listOf(1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7), list.flatMap { listOf(it, it + 1) })

groupBy
返回一个映射表,该表包括经指定函数对原始集合中元素进行分组后的元素。
assertEquals(mapOf(“odd” to listOf(1, 3, 5), “even” to listOf(2, 4, 6)), list.groupBy { if (it % 2 == 0) “even” else “odd” })

map
返回一个列表,该列表包含对原始集合中每个元素进行转换后结果。
assertEquals(listOf(2, 4, 6, 8, 10, 12), list.map { it * 2 })

mapIndexed
返回一个列表,该列表包含对原始集合中每个元素进行转换后结果和它们的索引。
assertEquals(listOf (0, 2, 6, 12, 20, 30), list.mapIndexed { index, it -> index * it })

mapNotNull
返回一个列表,该列表包含对原始集合中非null元素转换后的结果。
assertEquals(listOf(2, 4, 6, 8), listWithNull mapNotNull { it * 2 })

4、元素操作

contains
在集合中如果找到指定元素,则返回true。
assertTrue(list.contains(2))

elementAt
返回指定索引位置的元素。如果索引超出这个集合的范围,则抛出IndexOutOfBoundsException。
assertEquals(2, list.elementAt(1))

elementAtOrElse
返回指定索引位置的元素。如果索引超出这个集合的范围,则返回调用默认函数的结果。
assertEquals(20, list.elementAtOrElse(10, { 2 * it }))

elementAtOrNull
返回索引位置的元素。如果索引超出这个集合的范围,则返回null。
assertNull(list.elementAtOrNull(10))

first
返回与指定条件相符的第一个元素。
assertEquals(2, list.first { it % 2 == 0 })

firstOrNull
返回与指定条件相符的第一个元素。如果没有找到相符的元素,则返回null。
assertNull(list.firstOrNull { it % 7 == 0 })

indexOf
返回第一个元素的索引。如何集合没有包含元素,则返回-1。
assertEquals(3, list.indexOf(4))

indexOfFirst
返回第一个与指定条件相符的元素索引。如果集合没有包含这样的元素,则返回 -1。
assertEquals(1, list.indexOfFirst { it % 2 == 0 })

indexOfLast
返回最后一个与指定条件相符的元素索引。如果集合没有包含这样的元素,则返回 -1。
assertEquals(5, list.indexOfLast { it % 2 == 0 })

last
返回与指定条件相符的最后一个元素。
assertEquals(6, list.last { it % 2 == 0 })

lastIndexOf
返回最后一个元素索引。如果集合没有包含元素,则返回 -1。
val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)
assertEquals(5, listRepeated.lastIndexOf(5))

lastOrNull
返回与指定条件相符的最后一个元素。如果没有找到这样的元素,则返回null。
val list = listOf(1, 2, 3, 4, 5, 6)
assertNull(list.lastOrNull { it % 7 == 0 })

single
返回与指定条件相符的单一元素。如果没有或有多个相符的元素,则抛出异常。
assertEquals(5, list.single { it % 5 == 0 })

singleOrNull
返回与指定条件相符的单一元素。如果没有找到这样元素或有找到多个这样元素,则返回null。
assertNull(list.singleOrNull { it % 7 == 0 })

5、生成操作

merge
返回一个列表,该列表由两个集合中有相同索引元素经转换函数转换而组成的。这个列表的长度是最大集合的长度。
val list = listOf(1, 2, 3, 4, 5, 6)
val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)
assertEquals(listOf(3, 4, 6, 8, 10, 11), list.merge(listRepeated) { it1, it2 -> it1 + it2 })


partition
将原始集合拆分一对集合,一个集合包含判断条件为true的元素,另一个集合包含判断条件为false的元素。
assertEquals(Pair(listOf(2, 4, 6), listOf(1, 3, 5)), list.partition { it % 2 == 0 })

plus
返回一个列表,该列表包含原始集合的所有元素和指定集合的所有元素。由于函数名称原因,我们可以使用“+”操作符。
assertEquals(listOf(1, 2, 3, 4, 5, 6, 7, 8), list + listOf(7, 8))


zip
返回一个列表,该列表由两个集合中相同索引元素建立的元素对。这个列表长度为最短集合的长度。
assertEquals(listOf(Pair(1, 7), Pair(2, 8)), list.zip(listOf(7, 8)))

6、 排序操作

reverse
返回逆序元素列表。
val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(5, 7, 2, 3), unsortedList.reverse())

sort
返回所有元素分类排序列表。
assertEquals(listOf(2, 3, 5, 7), unsortedList.sort())

sortBy
返回所有元素列表,其元素通过特定的比较器分类排序。
assertEquals(listOf(3, 7, 2, 5), unsortedList.sortBy { it % 3 })

sortDescending
返回所有元素分类排序列表,其顺序为降序。
assertEquals(listOf(7, 5, 3, 2), unsortedList.sortDescending())

sortDescendingBy
返回所有元素的分类排序列表,其顺序为通过特定排序函数结果的降序。
assertEquals(listOf(2, 5, 7, 3), unsortedList.sortDescendingBy { it % 3 })

PS

其实最常见的集合函数运用,我在最开始的时候,就以Array数组为例讲解出来了,我觉得集合的函数运用至少得学到最开始Array中讲的,然后上面对各个函数的讲解可以看一看,知道有这么一个东西,在项目开发中能有所想起,提高开发效率。

感谢网友的提供,能让我也一同学习~~~

今天Kotlin的集合大学习到这里就告一段落了,接下来继续一起学习,过节了~~~

谢谢支持~~~

点赞