高阶函数
高阶函数以另一个函数作为参数或者返回值，其可用Lambda或函数引用表示
函数类型
下面将Lambda存储在sum变量中，其是函数类型
val sum = { x: Int, y: Int -> x + y }
完整的函数类型为(para1,prar2…) -> returnValue
val a: Int = 0
val sum: (Int, Int) -> Int = { x, y -> x + y }
val sum2: ((Int, Int) -> Int) = { x, y -> x + y } //感觉这样可读性更高
若返回类型可空则为
val canReturnNull: (Int) -> Int? = { null }
若变量类型本身为空，而不是函数类型返回值可空，则为
val funOrNull: ((Int) -> Int?)? = null
调用作为参数的函数
如下，参数为函数类型，并在内部调用，根据传进来的参数实现不同的操作
fun twoAndThree(operation: (Int, Int) -> Int) {
val result = operation(2, 3)
println("result = $result")
}
twoAndThree { a, b -> a + b }
twoAndThree { a, b -> a * b }
如下对String实现filter，遍历字符串，若符合条件则添加到StringBuilder
fun String.filter(predicate: (Char) -> Boolean): String {
val sb = StringBuilder()
for (index in 0 until length) {
val element = get(index)
if (predicate(element))
sb.append(element)
}
return sb.toString()
}
println("1abc".filter { it in 'a'..'z' })
Java中使用函数类型
一个函数类型的变量是FunctionN接口的一个实现，其内部的invoke方法调用Lambda函数体
fun process(f: (Int) -> Int){
println(f(1))
}
上面Kotlin函数接收一个函数类型，并调用该函数传入1，打印返回值，在Java中可直接传递Lambda
public class Test {
public static void run() {
JoinKt.process(number -> number + 1);
}
}
而在Java8之前可显示创建Function1，通过invoke代替Lambda
public class Test {
public static void run() {
JoinKt.process(new Function1<Integer, Integer>() {
@Override
public Integer invoke(Integer integer) {
integer = integer + 1;
System.out.println(integer);
return integer;
}
});
}
}
若使用带Lamba的扩展函数，需要将调用者作为第一个参数传递，且不能用void代替Unit作为返回值
public class Test {
public static void run() {
List<String> strings = new ArrayList<>();
strings.add("1");
CollectionsKt.forEach(strings, s -> {
System.out.println(s);
return Unit.INSTANCE;
});
}
}
函数类型的参数设置默认值
fun <T> joinToString(
collection: Collection<T>,
separator: String = "",
prefix: String = "",
postfix: String = ""
): String {
val result = StringBuilder(prefix)
for ((index, element) in collection.withIndex()) {
if (index > 0)
result.append(separator)
result.append(element)
}
result.append(postfix)
return result.toString()
}
对于上面代码，添加一个函数类型的参数，并指定默认行为为拼接字符串
fun <T> joinToString(
collection: Collection<T>,
separator: String = "",
prefix: String = "",
postfix: String = "",
transform: (T) -> String = { it.toString() }
): String {
val result = StringBuilder(prefix)
for ((index, element) in collection.withIndex()) {
if (index > 0)
result.append(separator)
result.append(transform(element))
}
result.append(postfix)
return result.toString()
}
在实际调用时，可传入Lambda修改默认行为
val letters = listOf("a", "b")
println(joinToString(letters))
println(joinToString(letters, transform = { it.toUpperCase() }))
函数类型的参数设置null值
将函数类型的参数设置为可空，并在调用时检查
fun foo(callback: (() -> Unit)?) {
if (callback != null) {
callback()
}
}
或者显式非空调用invoke
fun foo(callback: (() -> Unit)?) {
callback?.invoke()
}
返回函数的函数
如下函数根据运输方式返回不同的计算方式，getCost()根据不同的Delivery返回一个参数为Order，返回值为Double的函数
enum class Delivery { STANDARD, EXPEDITED }
class Order(val itemCount: Int)
fun getCost(delivery: Delivery): (Order) -> Double {
if (delivery == Delivery.EXPEDITED) {
return { order -> 2.0 * order.itemCount }
}
return { order -> 1.0 * order.itemCount }
}
在调用时，使用val变量接收该函数
val cost = getCost(Delivery.EXPEDITED)
println("cost = " + cost(Order(3)))
内联函数
使用 inline 修饰的函数被使用时编译器不会生成函数调用的代码，而是使用真实代码替换每一次的函数调用
inline fun <T> synchronized(lock: Lock, action: () -> T): T {
lock.lock()
try {
return action()
} finally {
lock.unlock()
}
}
fun foo(l: Lock) {
println("Before lock")
synchronized(l) {
println("Action")
}
println("After lock")
}
对于内联函数synchronized的调用，会被转化为
fun foo(l: Lock) {
println("Before lock")
l.lock()
try {
println("Action")
} finally {
l.unlock()
}
println("After lock")
}
内联函数的限制
函数类型的变量作为内联函数的参数，不能被内联，因为只有当外层的内联展开后，其中的Lambda才会被正常调用
inline fun <T> synchronized(lock: Lock, action: () -> T): T {
lock.lock()
try {
return action()
} finally {
lock.unlock()
}
}
class LockOwner(val lock: Lock) {
fun runUnderLock(body: () -> Unit) {
synchronized(lock, body)
}
}
runUnderLock()将函数类型的变量作为参数body，传递给synchronized()，只能内联synchronized()，而不能一并内联runUnderLock()
class LockOwner(val lock: Lock) {
fun runUnderLock(body: () -> Unit) {
lock.lock()
try {
body()
} finally {
lock.unlock()
}
}
}
如果参数为Lambda且在某个地方被保存，不能被内联，如Sequence中操作集合的方法
class Man(val name: String, val sex: String)
fun Man.toWoman(transform: (String) -> String): WoMan {
return WoMan(this, transform)
}
class WoMan(val man: Man, val change: (String) -> String) {
override fun toString(): String {
return "name=${man.name},sex=" + change(man.sex)
}
}
如上，Lambda传递给Woman的构造函数并保存到change属性，toWoman()不能声明为内联函数
用noinline修饰的参数，不能被内联
inline fun foo(inlined: () -> Unit, noinline: () -> Unit) {
}
使用use关闭流
在Java中操作文件通常使用try-with-resource
static String readFirstLineFromFile(String path) throws IOException {
try (BufferedReader br = new BufferedReader(new FileReader(path))) {
return br.readLine();
}
}
而在Kotlin中可以使用uer代替，其会自动关闭流
fun readFirstLineFromFile(path: String): String {
BufferedReader(FileReader(path)).use { br ->
return br.readLine()
}
}
高阶函数中的控制流
使用标签返回
内联Lambda中的return语句默认返回到外层函数，如下不会打印 not Fount
class Person(val name: String, val age: Int)
fun find() {
val list = listOf(Person("A", 18), Person("A", 18))
list.forEach {
if (it.name == "A") {
println("Found")
return
}
}
println("not Found")
}
若使用标签，可实现Lambda的局部返回，如下使用@label表示标签，会打印 not Found
class Person(val name: String, val age: Int)
fun find() {
val list = listOf(Person("A", 18), Person("A", 18))
list.forEach label@{
if (it.name == "A") {
println("Found")
return@label
}
}
println("not Found")
}
使用Lambda作为参数的函数名可以作为标签，如下使用foreach作为标签，但如果显示指定了Lambda的标签，再使用函数名作为标签会失效
class Person(val name: String, val age: Int)
fun find() {
val list = listOf(Person("A", 18), Person("A", 18))
list.forEach {
if (it.name == "A") {
println("Found")
return@forEach
}
}
println("not Found")
}
匿名函数
如果一个Lambda包含多个局部返回语句会变得笨重，此时可以使用匿名函数替代
class Person(val name: String, val age: Int)
val list = listOf<Person>()
list.filter(fun(person): Boolean {
return person.age < 30
})
list.filter(fun(person) = person.age < 30)
