1. ? 和 !!
?加在变量名后，系统在任何情况不会报它的空指针异常。
!!加在变量名后，如果对象为null，那么系统一定会报异常！
上述是两个符号的简单概念，为了更好的解释这两个概念，我们先从java代码入手，如下例：
ArrayList<String> myList = null; // 创建一个null的队列
Log.d("TAG", "-->> List Size = " + myList.size());
这个例子中，执行到 Log 打印队列长度时，报错
“ Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'int java.util.ArrayList.size()' on a null object reference”
然而在 KT 中，在调用 myList 的时候在它后面加上一个问号 myList?.size() ，则会在 myList 为null 的时候直接打印出null ，不会抛出 NullPointerException 。
在Android Studio 中，将上述代码自动转换为 KT代码写法后，如下：
val myList: ArrayList<String>? = null // 创建一个null的队列
Log.d("TAG", "-->> List Size = " + myList!!.size)
编译器为什么自动将 myList.size() 变成了 myList!!.size，而不是加上 ? 呢？
这是因为编译器在转换时为了保证代码转换前后的一致性所造成的。换言之，在Java 上出异常的，转换到 KT 上，编译器依然会让它保持抛出异常，NullPointerException 也是如此。
综上所述，使用 ? 时，程序会进行非空判断，如为空，则返回 null ，不会造成程序报错。但注意返回的是 null 而非 0 ，如果用于判断，参考 2中 ?:的讲解；
使用 !! 时，会对对象进行非空判断，并且会像 java 代码一样抛出异常。
2. ?：
对象A ?: 对象B 表达式，意思为，当对象 A值为 null 时，那么它就会返回后面的对象 B。
val roomList: ArrayList<KTBean>? = null
if (roomList?.size > 0) {
Log.d("TAG", "-->> 列表数不是0")
}
如上段代码，执行时会发现如下提示
此时，就可以使用上述讲到的 ?: ，当 ?: 前面的对象为空时，返回后面的值，如下：
val roomList: ArrayList<Room>? = null
val mySize= roomList?.size ?: 0
此时，mySize 的值就为0，因为 roomList?.size 为空，可用于列表是否为空的判断，如下：
val roomList: ArrayList<KTBean>? = null
if (roomList?.size ?: 0 > 0) { // 这一行添加了?:
Log.d("TAG", "-->> 列表数不是0")
}
至此，用上面的 ？和 ?: 就可以避免程序中出现的 NullPointerException 。
3. ::
Kotlin 中 双冒号操作符 表示把一个方法当做一个参数，传递到另一个方法中进行使用，通俗的来讲就是引用一个方法。
详情参考：https://blog.csdn.net/lv_fq/article/details/72869124
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. == 和 ===
code 1
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
}
code 2
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中，=== 表示比较对象地址，== 表示比较两个值大小。
所以无论是 a == a 还是 a === a 都是返回true，因为是同一个变量，数值大小和地址都是相等的。
现在重点看 a1 和 a2，这里的把 a 分别赋给 a1 和 a2。
code 1 和 code 2 的不同点在于 a1 和 a2 的类型。一个是Int，一个是Int?。它们的区别如下：
如果我们使用的是
val a : Int = 999这种方式，这时的a其实就是个数值, 不涉及装箱的问题, 也就不是对象。
而如果我们使用的是val a: Int? = 999这种方式,这时的a是一个Int型对象, 因为它涉及到装箱问题。
code 1 中 a1 和 a2 都没有装箱，所以不是对象，只是数值，所以数值大小和地址都是相等的。而 code 2 中 a1 和 a2 涉及到装箱，已经变成了对象，此时它们的数值仍然相等，但地址已经不同了（因为是不同对象）。
code 3
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
}
code 3 和 code 2 做比较，发现将a也装箱后，a1 === a2返回 true，这是为什么呢？
因为这里的a经过装箱后本身已经一个对象，所以赋给a1和a2的时候是把直接把对象a赋给它们，所以此时a1和a2指的是同一个对象（对象a）。既然是同一个对象，那么数值大小和地址肯定都是相等的了（也就是说a，a1和a2这三个对象指向同一处地址，所以其实 a === a1和a === a2也是返回true）。
code 4
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
}
code 4 和 code 2 做比较，明明只是改了一下a的值，为什么就会产生不同的结果呢？
这里跟 Java 中是一样的，在范围是 [-128, 127] 之间的数装箱时并不会创建新的对象，所以这里a1和a2装箱后的对象是同一个，a1 === a2也就返回true了。这里改为128或-129就又会变成false了。
