Android面试题之Kotlin函数式编程中包含的三大类函数

本文首发于公众号"AntDream"，欢迎微信搜索"AntDream"或扫描文章底部二维码关注，和我一起每天进步一点点

三大类函数

函数式编程中函数包含三大类函数：变换、过滤和合并

变换类函数---map函数

函数式编程范式支持的设计理念就是不可变数据的副本在链上的函数间传递
map返回的集合中的元素个数和输入集合必须一样，不过，返回的新集合里的元素可以是不同类型的

kotlin 复制代码

fun main() { 
    val animals = listOf("zebra", "dog", "cat") 
    val babies = animals .map { animal -> "a baay baby with a tail" }  
    println(animals) println(babies)
    val animalsLength:List<Int> = animals.map { it.length }
    println(animalsLength)

}

变换类函数---flatMap函数

flatMap函数操作一个集合的集合，将其中多个集合中的元素合并后返回一个包含所有元素的单一集合

kotlin 复制代码

fun main() { 
    val result = listOf(listOf(1,2,3), listOf(4,5,6)).flatMap { it }
    println(result)
}

//输出 [1, 2, 3, 4, 5, 6]

过滤函数 ---filter

kotlin 复制代码

fun main() {
    val result = listOf("Java", "Jim", "Tom")
        .filter { it.contains("J") }
    //输出[Java, Jim]
    println(result)

    val items = listOf(
        listOf("red apple", "green apple"),
        listOf("red fish", "blue fish"),
        listOf("yellow banana")
    )
    val redItems = items.flatMap { it -> it.filter { it.contains("red") } }
    //输出[red apple, red fish]
    println(redItems)
}



//找出集合中的素数
fun main() {
    val numbers = listOf(7,4,6,3,43,11,32)
    val newNumbers =  numbers.filter { numbers ->
        //[2,number)
        (2 until numbers).map { numbers % it }
            .none { it == 0 }
    }
    //输出[7, 3, 43, 11]
    println(newNumbers)
}

合并函数 ---zip

kotlin 复制代码

fun main() {
    val employees = listOf("Jack", "Jason", "Tim")
    val ages = listOf(19,20,30)
    val employeeAges = employees.zip(ages).toMap()
    //输出{Jack=19, Jason=20, Tim=30}
    println(employeeAges)
}

合并函数 --- fold

kotlin 复制代码

fun main() {
    //将每个元素值乘以3后累加
    val result = listOf(1,2,3,4).fold(0){ amount, number ->
        println("amount:$amount")
        amount + (number * 3)
    }
    //输出amount:0
    //amount:3
    //amount:9
    //amount:18
    //30
    println(result)
}

序列

List、Set、Map集合类型，这几个集合类型统称为及早集合（eager collection），这些集合的任何一个实例在创建后，它要包含的元素都会被加入并允许你访问
惰性集合(lazy collection)类似于惰性初始化，惰性集合类型的性能表现优异，尤其是用于包含大量元素的集合时，因为集合的元素时按需产生的
序列属于惰性集合，用generateSequence函数生成
generateSequence函数接受一个初始种子值作为序列的起步值，在用generateSequence定义的序列上调用一个函数时，generateSequence会调用你指定的迭代器函数，决定要产生的值

kotlin 复制代码

//序列 
//找出素数 
fun Int.isPrime() : Boolean {
    (2 until this).map { if (this % it == 0) { return false } } return true 
}
fun main() { 
    //假定0-5000之内，可以找到1000个素数，take函数如果不足1000就会退出 
    val tolist = (1..5000).toList().filter { it.isPrime() }.take(1000)
    //输出670 
    println(tolist.size)
}

scss 复制代码

//用序列来生成
//filter是过滤的条件
//take用来限定要产生的元素数量
//初始值2满足filter的条件，sequence里面有一个count会+1
//count+1后没有超出take参数的范围就会执行value+1,然后再看看符不符合filter条件
//符合的话count继续+1
val oneThousandPrimes: Sequence<Int> = generateSequence(2){value ->
    value + 1
}.filter { it.isPrime() }.take(10)
//输出[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
println(oneThousandPrimes.toList())

欢迎关注我的公众号查看更多精彩文章！