Kotlin中 ?、!!、?:、:: 、->、== 符号的简单说明

1.? 和 !!

"?"加在变量名后，系统在任何情况不会报它的空指针异常。
"!!"加在变量名后，如果对象为null，那么系统一定会报异常！

java代码：（这种情况下一定会报空指针异常）

ArrayList<String> myList = null;     //  创建一个null的队列
Log.d("TAG", "-->> List Size = " + myList.size());

kt代码：（会直接打印出null，不会报空指针异常）

val myList: ArrayList<String>? = null     //  创建一个null的队列
Log.d("TAG", "-->> List Size = " + myList!!.size)

使用 !! 时，会对对象进行非空判断，并且会像 java 代码一样抛出异常

2.?:

对象A ?: 对象B 表达式，意思为，当对象 A值为 null 时，那么它就会返回后面的对象 B。意思就是使用?:时，如果前面的对象为空，那么就会自动返回后面的对象。代替了Java中的三元表达式

kt代码：（这个时候mySize的值为0）

val roomList: ArrayList<Room>? = null
val mySize= roomList?.size ?: 0  

总结：用 ? 和 ?: 就可以避免程序中出现的 NullPointerException

3.::

表示把一个方法当做一个参数，传递到另一个方法中进行使用，通俗的来讲就是引用一个方法

kt代码：（这个时候输出结果为 result is {param1 , param2} ）

fun main(args: Array<String>) {
    println(lock("param1", "param2", ::getResult))
}

/**
 * @param str1 参数1
 * @param str2 参数2
 */
fun getResult(str1: String, str2: String): String = "result is {$str1 , $str2}"

/**
 * @param p1 参数1
 * @param p2 参数2
 * @param method 方法名称
 */
fun lock(p1: String, p2: String, method: (str1: String, str2: String) -> String): String {
    return method(p1, p2)
}

如果我们调用其他类中的某一个方法：

fun main(args: Array<String>) {
    var d = Test()
    println(lock("param1", "param2", d::getResult))
}

我们在类中的某个方法中使用双冒号调用当前 Class 的内部方法时：

class Test1 {
    fun isOdd(x: Int) = x % 2 != 0

    fun test() {
        var list = listOf(1, 2, 3, 4, 5)
        println(list.filter(this::isOdd))
    }
}

一般情况下调用当前类的方法this是可以省略的，这里不省略是因为：
为了防止作用域混淆 ， :: 调用的函数如果是类的成员函数或者是扩展函数，必须使用限定符this。
如果把 isOdd 写到 class 外部 (全局) 这里也是可以省略this。

4.->

fun <T, R> Collection<T>.fold(
    initial: R, 
    combine: (acc: R, nextElement: T) -> R
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}

在上述代码中，参数 combine 具有函数类型 (R, T) -> R，因此 fold 接受一个函数作为参数， 该函数接受类型分别为 R 与 T 的两个参数并返回一个 R 类型的值。 在 for-循环内部调用该函数，然后将其返回值赋值给 accumulator。（不明白）

5.== 和 ===

code1

fun main(args: Array<String>) {
    val a : Int = 1000
    println(a == a) //true
    println(a === a) //true
    val a1 : Int = a
    val a2 : Int = a
    println(a1 == a2) //true
    println(a1 === a2) //true
}

code2

fun main(args: Array<String>) {
    val a : Int = 1000
    println(a == a) //true
    println(a === a) //true
    val a1 : Int? = a
    val a2 : Int? = a
    println(a1 == a2) //true
    println(a1 === a2) //false
}

在Kotlin中，=== 表示比较对象地址，== 表示比较两个值大小。
注意code2中最后一行为false，因为Int?涉及到装箱的问题，已经变成对象了，所以a1和a2的大小还是一样的，但是地址不同了（因为是不同的对象）。
code3

fun main(args: Array<String>) {
    val a : Int? = 1000
    println(a == a) //true
    println(a === a) //true
    val a1 : Int? = a
    val a2 : Int? = a
    println(a1 == a2) //true
    println(a1 === a2) //true
}

比较code2和code3，他俩最开始一行是不一样的，但是code3中a1 === a2是为ture的，因为第一行的a经过装箱后已经是一个对象，所以赋给a1和a2的时候是把直接把对象a赋给它们，所以此时a1和a2指的是同一个对象（对象a）。
code4

fun main(args: Array<String>) {
    val a : Int = 100
    println(a == a) //true
    println(a === a) //true
    val a1 : Int? = a
    val a2 : Int? = a
    println(a1 == a2) //true
    println(a1 === a2) //true
}

比较code4和code2，他俩只有第一行a的值不一样，但是在范围是 [-128, 127] 之间的数装箱时并不会创建新的对象。所以。

6.三个引号"""

表示可以包含换行、反斜杠

7.$

方便字符串的拼接，可以用一个$$符号拼接变量和表达式。
注意：在Kotlin中，美元符号{'$'}（由于与简述的语法冲突，请看自己编写的东西）