一. 高阶函数
参数类型包含函数类型或返回值类型为函数类型的函数为高阶函数。
//参数包含函数类型
fun needsFunction(block: () -> Unit) {
block()
}
// 返回值类型为函数类型
fun returnsFunction(): () -> Long {
return { System.currentTimeMillis()}
}
常见的高阶函数
inline fun IntArray.forEach(action: (Int) -> Unit): Unit {
for (element in this) action(element)
}
inline fun IntArray.map(transform: (Int) -> R): List {
return mapTo(ArrayList(size), transform)
}
高阶函数的调用
intArray.forEach(::println)
intArray.forEach({
println("Hello $it")
})
// 函数类型为最后一个参数可移到括号外边
intArray.forEach() {
println("Hello $it")
}
// 只有一个 Lambda 表达式作为参数可省略小括号
intArray.forEach {
println("Hello $it")
}
二. 内联函数
- 内联函数的概念
通过内联（即函数内容直插到调用处）的方式来优化代码层级和内存占用。
val ints = intArrayOf(1,2,3,4)
ints.forEach{
println("Hello $it")
}
//forEach的定义
inline fun IntArray.forEach(action: (Int) -> Unit): Unit {
for (element in this) action(element)
}
// 其实编译期最后生成的
val ints = intArrayOf(1,2,3,4)
for (element in this){
println("Hello $element")
}
使用内联函数的好处是减少了函数的调用，调用栈变浅了。但并不是加上内联就一定是优化。
- 定义内联函数
用 inline 关键字修饰
inline fun hello(){
println("Hello")
}
- 高阶函数与内联更配
cost{
println("Hello")
}
inline fun cost(block: () -> Unit) {
val start = System.currentTimeMillis()
block()
println(System.currentTimeMillis() - start)
}
高阶函数内联：
（1）函数本身被内联到调用处
（2）函数的函数参数被内联到调用处
高阶函数与内联更配的原因：在调用 cost 函数的时候会传入一个 Lambda 表达式参数，前面说过 Lambda 表达式是一个匿名函数，也就是该参数也是一个函数，所以在调用 cost 的时候还要创建一个 block 对象，而且还是一个只用一下，马上就被抛弃的对象，这个时候成本就高了。如果加上 inline，代码就变成了如下，
val start = System.currentTimeMillis()
println("Hello")
println(System.currentTimeMillis() - start)
不仅把自己铺平到调用处，连参数也铺平过来了。这种优化就前面那种简单情形不一样了，因为它避免了参数中函数类型的对象的创建，所以这种优化的性能提升很明显。
inline 使用场景
如果写的是高阶函数，会有函数类型的参数，用就是了。不过如果这个函数太长而且有太多处调用，可能会因为多处内联而导致编译结果明显增大，这时候，就可能是负优化。内联高阶函数的 return
val ints = intArrayOf(1,2,3,4)
ints.forEach{
if (it == 3) return@forEach //return@forEach 表示在it =3 这次的时候return，跳出了这次的内联函数调用
println("Hello $it")
}
// 等同于
val ints = intArrayOf(1,2,3,4)
for (element in ints) {
if (element == 3) continue
println("Hello $element")
}
- non-local return
非本地退出
inline fun nonLocalReturn(block: () -> Unit) {
block()
}
nonLocalReturn {
return //从外部函数返回
}
比如：直接从退出 main 函数
fun main() {
// local return
nonLocalReturn {
return
}
}
不是所有地方都可以这么调用的，有可能存在不合法的 non-local return，因为 block 的调用处与定义处不在同一个调用上下文，比如下方的 block
inline fun Runnable(block: () -> Unit): Runnable {
return object: Runnable {
override fun run() {
block()
}
}
}
如果不允许 non-local return ，添加 crossinline 关键字 ,
inline fun Runnable(crossinline block: () -> Unit): Runnable {
return object: Runnable {
override fun run() {
block()
}
}
}
也可以添加 noinline 关键字，彻底禁止函数参数被内联
inline fun Runnable(noinline block: () -> Unit): Runnable {
return object: Runnable {
override fun run() {
block()
}
}
}
- 内联属性
没有 backing-field 的属性的 getter/setter 可以被内联
var pocket.Double = 0.0
var money. Double
inline get() = pocket
inline set(value) {
pocket = value
}
- 内联函数的限制
（1）public/protected 的内联方法只能访问对应类的 public 成员；
（2）内联函数的内联函数参数不能被存储（赋值给变量）；
（3）内联函数的内联函数参数只能传递给其他内联函数参数；
三. 几个有用的高阶函数
| 函数名 | 介绍 |
|---|---|
| let | val r = X.let { x -> R } |
| run | val r = X.run { this: X -> R } |
| also | val x = X.also { x -> Unit } |
| apply | val x = X.apply { this: X -> Unit } |
| use | val r = Closeable.use { c -> R } |
四. 集合变换与序列
- 遍历
for
// java
for (int I = 0; I <= 10; I++) {
System.out.println(i);
}
// Kotlin
for (I in 0 .. 10) {
println(i)
}
for each ...
// java
for (int e : list) {
System.out.println(e);
}
// Kotlin
for (e in list) {
println(e)
}
forEach 函数
// java
list.forEach((e) -> {
System.out.println(e);
});
// Kotlin
list.forEach {
println(it)
}
- 集合的映射操作举例
| 函数名 | 说明 |
|---|---|
| filter | 保留满足条件的元素 |
| map | 集合中的所有元素--映射到其他元素构成新集合 |
| flatMap | 集合中的所有元素--映射到新集合并合并这些集合得到新集合 |
filter 操作
// java
list.stream().filter(e -> e % 2 == 0);
// kotlin
list.filter {it % 2 == 0}
map 操作
// java
list.stream().map(e -> e * 2 + 1);
// kotlin
list.map {it * 2 + 1}
flatMap 操作
// java
list.stream().flatMap(e -> {
ArrayList integers = new ArrayList<>(e);
for (int i = 0; i < e; i++) {
integers.add(i);
}
return integers.stream();
});
// kotlin
list.flatMap {0 until it}
- 集合的聚合操作举例
| 函数名 | 说明 |
|---|---|
| sum | 所有元素求和 |
| reduce | 将元素一次按规则聚合，结果与元素类型一致 |
| fold | 给定初始值，将元素按规则聚合，结果与初始化值类型一致 |
flod 操作
list.fold(StringBuilder()) {
acc,i -> acc.append(i)
}
五. SAM （Single Abstract Method）转换
（1）一个参数类型为只有一个方法的接口的方法调用时可用 Lambda 表达式做转换作为参数；
（2）一个参数类型为只有一个方法的 Java 接口的 Java 方法调用时可用 Lambda 表达式做转换作为参数；
Java：
// java 的匿名内部类
ExecutorService executor = ...
executor.submit(new Runnable() {
@Override
public void run() {
System.out.println("run in executor.");
}
});
// Java 的 SAM，用 Lambda 表达式替代
ExecutorService executor = ...
executor.submit(() -> System.out.println("run in executor."));
Java 中 Lambda 表达式是没有自己类型的，必须有一个接口来接收它，而且这个接口还必须只有一个方法。
Kotlin：
// 匿名内部类的写法
executor.submit(object: Runnable{
override fun run() {
println("run in executor.")
}
})
// Kotlin 的 SAM
executor.submit { println("run in executor.") }
Kotlin 中的 Lambda 表达式本身是有自己的类型的，（） -> Unit 类型的 Lambda 转换为 Runnable
SAM 转换支持对比
| Java | Kotlin | |
|---|---|---|
| Java 接口 | 支持 | 支持 |
| Kotlin 接口 | 支持 | 不支持 |
| Java 方法 | 支持 | 支持 |
| Kotlin 函数（方法） | 支持 | 不支持 |
| 抽象类 | 不支持 | 不支持 |