Kotlin笔记（一）常量与变量

1、常量与变量定义

val a = 2 // 常量
var x = 5 // 变量
var name : String? // 可null变量

NULL检查机制

Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null 或配合 ?: 做空判断处理

//类型后面加?表示可为空
var age: String? = "23" 
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1

?. 判空辅助

当对象不为空时正常调用，为空则什么也不做

 if(a != null){ 
     val l = a.length 
 } 
// 简化
val l = a?.length

当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空。

data class RichTextEntity(
    var textAlign: Int? = 0, // 文本对齐方式：左0 中1 右2
    var ellipsize: Int? = 2, //省略号位置：左0 中1 右2
    var richTextDetailList: List<RichTextDetail>? = null
)

?: 判空辅助

如果左边表达式结果不为空，就返回左边表达式的结果；否则返回右边表达式的结果

val c = if(a != null){
    a.length
}else{
    b
}
// 简化。常用作指定默认值
val c = a?.length ?: b

!! 非空断言

非空断言运算符（!!）将任何值转换为非空类型，若该值为空则抛出异常。我们可以写 b!! ，这会返回一个非空的 b 值 （例如：在我们例子中的 String）或者如果 b 为空，就会抛出一个 NPE 异常：

val l = b!!.length

类型检测与类型转换

is 类型检测

is 运算符检测一个表达式是否某类型的一个实例。(类似于Java中的instanceof关键字)：

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` 在该条件分支内自动转换成 `String`
        return obj.length
    }
    // 在离开类型检测分支后，`obj` 仍然是 `Any` 类型
    return null
}

// 甚至
fun getStringLength(obj: Any): Int? {
    // `obj` 在 `&&` 右边自动转换成 `String` 类型
    if (obj is String && obj.length > 0) {
      return obj.length
    }

    return null
}

as 类型转换

如果对象不是目标类型，那么常规类型转换可能会导致 ClassCastException。 另一个选择是使用安全的类型转换，如果尝试转换不成功则返回 null：

val aInt: Int? = a as? Int

2、基本数据类型

Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 等。不同于 Java 的是，字符不属于数值类型，是一个独立的数据类型。

数字比较 ===

Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。数字类型也一样，所以在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。
在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。

val a: Int = 10000
println(a === a) // true，值相等，对象地址相等

//经过了装箱，创建了两个不同的对象
val a1: Int? = a
val a2: Int? = a

//虽然经过了装箱，但是值是相等的，都是10000
println(a1 === a2) //  false，值相等，对象地址不一样
println(a1 == a2) // true，值相等

注1： 案例中的类型是 Int? 可空类型，类型不同所以必须装箱，导致产生一个新对象。
这里类型都相同，都是数值类型，所以没有进行装箱操作。

val a: Int = 10000
val a1: Int = num
val a2: Int = num
println(a1 === a2)  //true

==注2：==在范围是 [-128, 127] 之间并不会创建新的对象，比较输出的都是 true，从 128 开始，比较的结果才为 false。

val a: Int = 100
//经过了装箱，创建了两个不同的对象
val a1: Int? = a
val a2: Int? = a

//虽然经过了装箱，但是值是相等的，都是100
println(a1 === a2) //  true，值相等，128 之前对象地址一样

类型转换 toDouble()

由于不同的表示方式，较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。

val a: Int = 1
val b: Double = a.toDouble()

每种数据类型都有下面的这些方法，可以转化为其它的类型：

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

==例外：==可以使用自动类型转化的情况，根据上下文环境可以推断出正确的数据类型而且数学操作符会做相应的重载。例如下面是正确的：

val l = 1L + 3 // Long + Int => Long

位操作符

对于Int和Long类型，还有一系列的位操作符可以使用，分别是：

shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与
or(bits) – 或
xor(bits) – 异或
inv() – 反向

字符

字符字面值用单引号括起来: ‘1’。 特殊字符可以用反斜杠转义。 支持这几个转义序列：\t、 \b、\n、\r、‘、"、\ 与 $。 编码其他字符要用 Unicode 转义序列语法：’\uFF00’。
我们可以显式把字符转换为 Int 数字：‘0’.toInt()

数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。
数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。

 //[1,2,3]
val a = arrayOf(1, 2, 3)
//[0,2,4]
val b = Array(3, { i -> (i * 2) })

//读取数组内容
println(a[0])    // 输出结果：1
println(b[1])    // 输出结果：2

注意: 与 Java 不同的是，Kotlin 中数组是不协变的（invariant）。
除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

字符串 String

本身不可变，字符可以使用索引访问：s[i]，可用 for 循环迭代for(c in str)

“”" 字符串字面值

Kotlin 有两种类型的字符串字面值：

1. 转义字符串：通过转义字符标识换行等符号，val s = “Hello\n”
2. 原始字符串：使用三个引号"““括起来，内部没有转义也可以包含换行以及任何其他字符。
   trimIndet() 去除每一行开头相同数量的空格。
   trimMargin()从每行的开头裁剪指定的字符串参数以及前面的空格，默认字符串”|”。

${} 字符串模板

表达式结果替换内容

var a = 1
val s1 = "a is $a" // 单变量不需要括号

a = 2
val s2 = "${s1.replace("is", "was")}, but now is $a" // 模板中的任意表达式：

lateinit 延迟初始化

倘若定义变量是可为空（Nullable），会导致使用时需要判空，或者使用非空断言!!。

var stringRequest: StringRequest? = null
stringRequest!!.tag = TAG

lateinit的作用是告诉编译器，这个不为空的变量，虽然目前没有对它赋值，但我在使用它之前，一定会对它赋值，肯定不为空，你不必报错。省去每次使用前的判空开销。
但同时需要保证调用之前已经完成初始化工作，可以通过代码判断是否已经完成初始化。

private lateinit var adapter : MsgAdapter 
// 判断 
if(!::adapter.isInitialized){ 
    adapter = MsgAdapter(msgList) 
} 

by lazy 懒加载

在一开始的时候不会执行，只有当 p变量首次被调用的时候，才会执行。

val p by lazy { ... } 

原理：只有by才是Kotlin 中的关键字，lazy在这里是一个高阶函数。在lazy函数中会创建并返回一个Delegate对象，当我们调用p属性的时候，其实调用的是Delegate对象的getValue()方法，然后getValue()方法中又会调用lazy函数传入的Lambda 表达式，这样表达式中的代码就可以得到执行了，并且调用p属性后得到的值就是Lambda 表达式中最后一行代码的返回值。