Android开发之Kotlin常见高阶函数

filter

过滤器，过滤出符合条件的数据。

val list1 = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val list2 = list1.filter {
    it < 4
}
Log.i(TAG, "===list1===$list1")
Log.i(TAG, "===list2===$list2")

//输出
===list1===[1, 2, 3, 4, 5, 6, 7, 8]
===list2===[1, 2, 3]

filterNot

和filter相反。

val list1 = listOf(1, 2, 3, 4, 5, 6, 7)
val list2 = list1.filter { it % 2 == 0 }
val list3 = list1.filterNot { it % 2 == 0  }
Log.i(TAG, "===list1===$list1")
Log.i(TAG, "===list2===$list2")
Log.i(TAG, "===list3===$list3")

//输出
===list1===[1, 2, 3, 4, 5, 6, 7]
===list2===[2, 4, 6]
===list3===[1, 3, 5, 7]

find

查找符合条件并返回第一个符合该条件的数据。和filter的区别：filter返回的是结果集合。find是找到第一个就返回值本身。

val list = listOf("a", "b", "c")
val find1 = list.find { it == "a" }
val find2 = list.find { it == "A" }

Log.i(TAG, "===find1===$find1")
Log.i(TAG, "===find2===$find2")

//输出
===find1===a
===find2===null

map

在内部创建一个新列表，并将其结果放入该列表中，然后返回该列表。

val list1 = listOf(1, 2, 3, 4, 5, 6)
val list2 = list1.map {
    it * it
}
Log.i(TAG, "===list1===$list1")
Log.i(TAG, "===list2===$list2")

//输出
===list1===[1, 2, 3, 4, 5, 6]
===list2===[1, 4, 9, 16, 25, 36]

mapTo

将集合中的元素转换成另一个集合的函数。可以通过提供自己的列表作为第一个参数来指定放置映射元素的目的地,将一个集合的元素映射到另一个集合，并将结果添加到目标集合中。

val list1= listOf(1,2,3,4,5,6)
val list2= mutableListOf<Int>()
list1.mapTo(list2){
   it*it
}
Log.i(TAG, "===list1===$list1")
Log.i(TAG, "===list2===$list2")

//输出
===list1===[1, 2, 3, 4, 5, 6]
===list2===[1, 4, 9, 16, 25, 36]

flatMap

遍历嵌套的集合，生成新的集合。

val list1 = mutableListOf(
    arrayOf("A", "B", "C"),
    arrayOf("D", "E"),
    arrayOf("F"),
)
val list2 = list1.flatMap {
    it.map { name -> "我是:$name" }
}
Log.i(TAG,"===list2===$list2")

//输出
===list2===[我是:A, 我是:B, 我是:C, 我是:D, 我是:E, 我是:F]

any

判断在数据列表中有没有符合条件的数据，返回的结果为布尔类型的值，true或者false。

val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val flag = list.any {
    it < 4
}
Log.i(TAG, "===list===$list")
Log.i(TAG, "===flag===$flag")

//输出
===list===[1, 2, 3, 4, 5, 6, 7, 8]
===flag===true

reduce

将集合元素从左到右依次累加，并返回积累的结果。

val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val total = list.reduce { acc, i ->
    println("acc:$acc,i:$i")
    Log.i(TAG, "===acc===$acc===i===$i")
    acc + i
}
Log.i(TAG, "===list===$list")
Log.i(TAG, "===total===$total")

//输出
===acc===1===i===2
===acc===3===i===3
===acc===6===i===4
===acc===10===i===5
===acc===15===i===6
===acc===21===i===7
===acc===28===i===8
===list===[1, 2, 3, 4, 5, 6, 7, 8]
===total===36

fold

和reduce用法类似，可以设置一个初始值。

val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val total = list.fold(1) { acc, i ->
    println("acc:$acc,i:$i")
    Log.i(TAG, "===acc===$acc===i===$i")
    acc + i
}
Log.i(TAG, "===list===$list")
Log.i(TAG, "===total===$total")

//输出
===acc===1===i===1
===acc===2===i===2
===acc===4===i===3
===acc===7===i===4
===acc===11===i===5
===acc===16===i===6
===acc===22===i===7
===acc===29===i===8
===list===[1, 2, 3, 4, 5, 6, 7, 8]
===total===37

maxByOrNull

求最大值。

val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val maxValue = list.maxByOrNull  { it }
Log.i(TAG, "===list===$list")
Log.i(TAG, "===maxValue===$maxValue")

//输出
===list===[1, 2, 3, 4, 5, 6, 7, 8]
===maxValue===8

minByOrNull

求最小值。

val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val minValue = list.minByOrNull  { it }
Log.i(TAG, "===list===$list")
Log.i(TAG, "===minValue===$minValue")

//输出
===list===[1, 2, 3, 4, 5, 6, 7, 8]
===minValue===1

count

计算列表中符合条件的元素的数量。

//计算字符串中字符的个数
val count1 = "abcdABCD".count()
//计算字符串中字符b的个数
val count2 = "abcdABCD".count{
    it == 'b'
}
//计算字符串中字符n的个数
val count3 = "abcdABCD".count{
    it == 'n'
}

Log.i(TAG, "===count1===$count1")
Log.i(TAG, "===count2===$count2")
Log.i(TAG, "===count3===$count3")

//输出
===count1===8
===count2===1
===count3===0

groupBy

分组，根据条件把集合拆分为一个Map<K,List>类型的集合。

val list1 = listOf("china", "beijing", "wuhan", "guangzhou", "Changsha", "wuhu")
val list2 = list1.groupBy {
    //按照首字母大写进行分组操作
    it.first().uppercase()
    //返回成Map的Key。  满足条件的元素相应的进入Map集合中的Value，List列表中
}
Log.i(TAG, "===list2===$list2")

//输出
===list2==={C=[china, Changsha], B=[beijing], W=[wuhan, wuhu], G=[guangzhou]}

joinToString

将集合转换为字符串的函数。

val result1 = (0..6).joinToString(",")
Log.i(TAG,"===result1===$result1")
val number = listOf("1", "2", "3", "4")
val result2 =  number.joinToString(separator = ",", prefix = "[", postfix = "]")
Log.i(TAG,"===result2===$result2")
val result3 = (0..100).joinToString(",", limit = 3, truncated = "...")
Log.i(TAG,"===result3===$result3")

//输出
===result1===0,1,2,3,4,5,6
===result2===[1,2,3,4]
===result3===0,1,2,...

takeWhile

遇到第一个不符合条件的就结束，留下前边的作为一个新的集合返回。

val list = listOf(31, 33, 15, 40)
val result = list.takeWhile {
    it >= 30
}
Log.i(TAG,"===result===$result")

//输出
===result===[31, 33]