集合

ArrayList给我们提供了一个add方法添加元素，但是在Kotlin使用lambda会简洁很多。

// 不使用lambda
fun main() {var res = ArrayList<String>()res.add("1")res.add("2")res.add("3")
}

// lambda
fun main() {var res = listOf("1", "2", "3")
}

使用listOf时需要注意，其产生的集合是不可变的，如果需要创建可变集合需要使用mutableListOf

Map

Kotlin中的Map写法：

// 不使用lambda
fun main() {var map = HashMap<String, Int>()map["a"] = 1map["b"] = 2
}

// lambda
fun main() {var map = mapOf("a" to 1, "b" to 2)
}

// 遍历输出
fun main() {var map = mapOf("a" to 1, "b" to 2)for ((key, value) in map) {println("$key is $value")}
}

函数式API

假设我们有一个水果集合。

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
}

我需要求得这个集合里面单词最长的元素，你可能会想到以下代码：

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")var maxWord = "";for (s in list) {if (s.length > maxWord.length) maxWord = s}println("max length : $maxWord" )
}

这样确实能做到，但是在Kotlin中我们可以使用函数式API来让它变得更加精简，它与Java的Stream十分相似。

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")val maxWord = list.maxBy { m -> m.length }println("max length : $maxWord")
}

其中Lambda表达式的语法结构为：

{参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}

其实上面提到的maxBy就是一个普通的函数，只不过它接收的是一个Lambda的参数而已，所以我们可以将maxBy的参数单独提取出来：

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")val la = {m : String -> m.length}val maxWord = list.maxBy(la)println("max length : $maxWord")
}

此外，Kotlin规定如果Lambda是函数的最后一个参数，可以将Lambda表达式移到函数括号外面，且如果Lambda是唯一一个参数时，函数参数括号可省略：

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")val maxWord = list.maxBy { m -> m.length }println("max length : $maxWord")
}

并且如果Lambda只有一个参数的话(上文代码中的m)，其参数可以省略并使用it代替。

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")val maxWord = list.maxBy { it.length }println("max length : $maxWord")
}

Java函数API

这是Java中Runnable接口的源码，它只有一个方法，在Java中Lambda可以写成如下形式：

@FunctionalInterface
public interface Runnable {/*** When an object implementing interface <code>Runnable</code> is used* to create a thread, starting the thread causes the object's* <code>run</code> method to be called in that separately executing* thread.* <p>* The general contract of the method <code>run</code> is that it may* take any action whatsoever.** @see     java.lang.Thread#run()*/public abstract void run();
}

    public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println("Hello");}}).start();}

但是在Kotlin中，这些代码可以再精简一些，由于Kotlin舍弃了new关键字，所以我们在Kotlin中创建匿名内部类需要使用object关键字。

fun main() {Thread(object : Runnable{override fun run() {println("Hello!")}}).start()
}

因为Runnable接口只有一个run方法，所以我们不写函数名称Kotlin也是知道我们的意思就是要实现run方法，这段代码可以再精简一点：

fun main() {Thread(Runnable {println("Hello!")}).start()
}

不过到这里还没结束，假设Java方法的参数列表中有且仅有一个Java单抽象方法接口参数，那么接口名也是可以省略的，并且按照我们之前提到的，假设Lambda表达式是方法参数的最后一个参数时，实现体可以放在方法括号后面，所以最终被精简的代码如下：

fun main() {Thread {println("Hello!")}.start()
}