2024年安卓最新Kotlin学习三：高阶函数，android 面试题高级

最后

给大家送上我成功跳槽复习中所整理的资料，由于文章篇幅有限，所以只是把题目列出来了

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

//

// println((0…6).map(::factorial).foldRight(StringBuilder()){i, acc ->

// acc.append(i).append(", ")

// })

//

// println((0…6).joinToString(", "))

println((0…6).map(::factorial))

//获取奇数

println((0…6).map(::factorial).filter { it % 2 == 1 })

//获取奇数位的结果

println((0…6).map(::factorial).filterIndexed { index, i -> index % 2 == 1 })

//遇到奇数就获取，直到非奇数就停止（即直到不符合条件的就停止）

println((0…6).map(::factorial).takeWhile { it % 2 == 1 })

val flatList2 = list.flatMap {

it.map {

“No. $it”

}

}

//以上等价于

val flatList3 = list.flatMap { intRange ->

intRange.map { intElement ->

“No. $intElement”

}

}

// flatList2.forEach(::println)

}

//求阶乘

fun factorial(n: Int): Int {

if (n == 0) return 1

return (1…n).reduce { acc, i -> acc * i }

}

4、综合2

---

data class Person(val name: String, val age: Int) {

fun work() {

println(“$name is working!!!”)

}

}

fun main(args: Array) {

// val person = findPerson()

// println(person?.name)

// println(person?.age)

// findPerson()?.let { person ->

// println(person.name)

// println(person.age)

// person.work()

// }

//

// findPerson()?.apply {

// println(name)

// println(age)

// work()

// }

// val br = BufferedReader(FileReader(“hello.txt”))

// with(br) {

// var line: String?

// while (true) {

// line = readLine() ?: break

// println(line)

// }

// close()

// }

// val br = BufferedReader(FileReader(“hello.txt”)).readText()

// println(br)

BufferedReader(FileReader(“hello.txt”)).use {

var line: String?

while (true) {

line = it.readLine() ?: break

println(line)

}

}

}

fun findPerson(): Person? {

return null

}

三、尾递归优化

=======

data class ListNode(val value: Int, var next: ListNode? = null)

tailrec fun findListNode(head: ListNode?, value: Int): ListNode? {

head ?: return null

if (head.value == value) return head

return findListNode(head.next, value)

}

//如果去掉 tailrec 就会报StackOverflowError

fun main(args: Array) {

val MAX_NODE_COUNT = 100000

val head = ListNode(0)

var p = head

for (i in 1…MAX_NODE_COUNT) {

p.next = ListNode(i)

p = p.next!!

}

println(findListNode(head, MAX_NODE_COUNT - 2)?.value)

}

fun factorial(n: Long): Long {

return n * factorial(n - 1)

}

data class TreeNode(val value: Int) {

var left: TreeNode? = null

var right: TreeNode? = null

}

fun findTreeNode(root: TreeNode?, value: Int): TreeNode? {

root ?: return null

if (root.value == value) return root

return findTreeNode(root.left, value) ?: return findTreeNode(root.right, value)

}

四、闭包

====

val string = “HelloWorld”

fun makeFun(): () -> Unit {

var count = 0

return fun() {

println(++count)

}

}

fun fibonacci(): Iterable {

var first = 0L

var second = 1L

return Iterable {

object : LongIterator() {

override fun nextLong(): Long {

val result = second

second += first

first = second - first

return result

}

override fun hasNext() = true

}

}

}

fun main(args: Array) {

// val x = makeFun()

// x()

// x()

// x()

for (i in fibonacci()) {

if (i > 100) break

println(i)

}

// val add5 = add(5)

// println(add5(2))

}

//fun add(x: Int) = fun(y: Int) = x + y

fun add(x: Int): (Int) -> Int {

data class Person(val name: String, val age: Int)

return fun(y: Int): Int {

return x + y

}

}

五、函数复合（f(g(x)),infix）

=====================

//f(g(x)) m(x) = f(g(x))

val add5 = {i: Int -> i + 5} // g(x)

val multiplyBy2 = {i : Int -> i * 2} // f(x)

fun main(args: Array) {

println(multiplyBy2(add5(8))) // (5 + 8) * 2

val add5AndMultiplyBy2 = add5 andThen multiplyBy2

val add5ComposeMultiplyBy2 = add5 compose multiplyBy2

println(add5AndMultiplyBy2(8)) // m(x) = f(g(x)) // (5 + 8) * 2

println(add5ComposeMultiplyBy2(8)) // m(x) = g(f(x)) // 8 * 2 + 5

}

//P1, P2,是参数值 R是返回值

infix fun <P1, P2, R> Function1<P1, P2>.andThen(function: Function1<P2, R>): Function1<P1,R>{

return fun(p1: P1): R{

return function.invoke(this.invoke(p1))

}

}

infix fun <P1,P2, R> Function1<P2, R>.compose(function: Function1<P1, P2>): Function1<P1, R>{

return fun(p1: P1): R{

return this.invoke(function.invoke(p1))

}

}

六、科理化（Currying）-函数调用链

=====================

fun log(tag: String, target: OutputStream, message: Any?){

target.write(“[$tag] $message\n”.toByteArray())

}

//fun log(tag: String)

// = fun(target: OutputStream)

// = fun(message: Any?)

// = target.write(“[$tag] $message\n”.toByteArray())

fun main(args: Array) {

log(“benny”, System.out, “HelloWorld”)

// log(“benny”)(System.out)(“HelloWorld Again.”)

::log.curried()(“benny”)(System.out)(“HelloWorld Again.”)

val consoleLogWithTag = (::log.curried())(“benny”)(System.out)

consoleLogWithTag(“HelloAgain Again.”)

consoleLogWithTag(“HelloAgain Again.”)

consoleLogWithTag(“HelloAgain Again.”)

consoleLogWithTag(“HelloAgain Again.”)

val bytes = “我是中国人”.toByteArray(charset(“GBK”))

val stringFromGBK = makeStringFromGbkBytes(bytes)

}

fun <P1, P2, P3, R> Function3<P1, P2, P3, R>.curried()

= fun(p1: P1) = fun(p2: P2) = fun(p3: P3) = this(p1, p2, p3)

val makeString = fun(byteArray: ByteArray, charset: Charset): String{

return String(byteArray, charset)

}

val makeStringFromGbkBytes = makeString.partial2(charset(“GBK”))

fun <P1, P2, R> Function2<P1, P2, R>.partial2(p2: P2) = fun(p1: P1) = this(p1, p2)

fun <P1, P2, R> Function2<P1, P2, R>.partial1(p1: P1) = fun(p2: P2) = this(p1, p2)

七、偏函数

=====

代码见上

最后

对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长。而不成体系的学习效果低效漫长且无助。时间久了，付出巨大的时间成本和努力，没有看到应有的效果，会气馁是再正常不过的。

所以学习一定要找到最适合自己的方式，有一个思路方法，不然不止浪费时间，更可能把未来发展都一起耽误了。

如果你是卡在缺少学习资源的瓶颈上，那么刚刚好我能帮到你。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

0190812213020117.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6aTEyMjg=,size_16,color_FFFFFF,t_70)

最后

对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长。而不成体系的学习效果低效漫长且无助。时间久了，付出巨大的时间成本和努力，没有看到应有的效果，会气馁是再正常不过的。

所以学习一定要找到最适合自己的方式，有一个思路方法，不然不止浪费时间，更可能把未来发展都一起耽误了。

如果你是卡在缺少学习资源的瓶颈上，那么刚刚好我能帮到你。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！