【编程语言】Kotlin快速入门 - 集合与Lambda

集合

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"] = 1
    map["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() {
            @Override
            public 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()
}