Kotlin语法基础，运算符

运算符

计算机程序中最小的程序单位成为表达式，每个表达式都可以由两部分组成，即操作数和运算符。操作数可以是变量、常量、类、数组、方法等，甚至是其他表达式。而运算符则用于支出表达式中单个或者多个操作数参与运算的规则，表达式通过运算之后产生的值依赖于表达式中包含的运算符的优先级和结核性。Kotlin语言包含了Java语言中的所有运算符的特性，并结合C语言的优点，增加自定义运算符的逻辑。这些运算符之中，主要包括有：算数运算符、区间运算符、逻辑运算符、关系运算符、赋值运算符、自增自减运算符等。

根据操作数的数量来划分，运算符又可以分为一目运算符、双目运算符。
- 一目运算符用于单一操作对象，又称单目运算符，如：++a、!b、i–等。
- 双目运算符是中置的，它拥有两个操作数，比如：a+3、a*b

Kotlin中没有三目运算符

基础运算符

基础运算符中包含了我们在编码工程中常用的一系列运算符，使我们编写程序的基本组成部分，了解基础运算符的用法可以尽可能的避免一些语法和逻辑上的基础性错误。

赋值运算符（=）

赋值运算a=b，表示等号右边的b初始化或者维护等号左边的a，b可以是变量、常量、字面量或表达式，如：

var IntA:Int = 5
val IntB:Int = 10

IntA = 2 + 1;
IntA = IntB

在Kotlin语言中还有另一种赋值运算符，叫做算术自反赋值运算符。它是一种由两个普通运算符组成的符合运算符，它包括：“+=”、“-=”、“*=”、“/=”、“%=”。使用方式如下：

var IntA:Int = 5
val IntB:Int = 10

IntA += IntB // 作用等于 IntA = IntA + IntB
IntA -= IntB // 作用等于 IntA = IntA - IntB
IntA *= IntB // 作用等于 IntA = IntA * IntB
IntA /= IntB // 作用等于 IntA = IntA / IntB
IntA %= IntB // 作用等于 IntA = IntA % IntB

算数运算符

算术运算符用于数值类型的运算，Kotlin语言支持基本的算术运算：加法“+”、减法“-”、乘法“*”、除法“/”、取余“%”、以及自增自减运算，如：

var IntA:Int = 5 + 5  // 10
val IntB:Int = 10 - 2 // 8
val IntC:Int = 3 * 4  // 12
val IntD:Int = 10 / 5 // 2
val IntE:Int = 10 % 3 // 1，除不尽，保留余数
val IntF:Int = 10 / 6 // 1，除不尽，仅保留整数部分

IntA = IntA / 0 // 报错，除数不能为0

自增自减运算符（++、–）

自增和自减运算符也是单目运算符，因为它只有一个操作数。自增运算符 “++” 表示使操作数加1，自减运算符 “–” 表示使操作数减1，其操作数可以使整数和浮点型等数字类型，如：

var intA : Int = 5

intA++ // 等于 intA = intA + 1
println("intA = " + intA)  // 输出 intA = 6

值得注意的是，自增运算符和自减运算符还会分为前置自增、后置自增、前置自减和后置自减，放在操作数前面的是前置，放在操作数后面的是后置运算符。

后置运算，则为先进性表达式返回，才进行自增、自减运算。前置运算符，则先进行自增、自减运算，在进行表达式返回。如：

var intIncA: Int = 5
var intIncB: Int = 5
var intIncC: Int = 5
var intIncD: Int = 5

println(++intIncA) // 先自增， 后返回。 输出 ：6
println(--intIncB) // 先自减， 后返回。 输出 ：4
println(intIncC--) // 先返回， 后自减。 输出 ：5
println(intIncD++) // 先返回， 后自增。 输出 ：5

字符串连接符(+)

两个字符串可以连接在一起成为一个新字符串，这种操作被成为字符串连接，在Kotlin语言中连接字符串可以用 “+”。如：

"hello " + "world" // 等于 "hello world"

字符串连接操作两边都是字符串，而很多情况下我们使用连接符仅有一侧是字符串，另一侧是其他类型。这个时候，系统则会自动调用toString方法转化为字符串，进行拼接。这个时候则调用则是String重载的plus方法，后面我们会具体介绍运算符重载，Kotlin中String的源码如下：

故此，进行字符串与其他类型拼接我们都将String类型的操作符至于连接符 “+” 左侧。

var intA : Int = 1
var StringA : String = "String Head "

println(intA + StringA) // 报错，调用的是Int.plus方法
println(StringA + intA) // 输入内容：String Head 1

关系运算符

关系运算符是指：使用关系运算符对两个操作数或表达式进行运算，产生的结果为真或者假。

运算符	名称	示例	功能	缩写
<	小于	a

println(10 == 10) // true
println(1 != 5)   // true
println(1 < 5)    // true
println(1 > 5)    // false
println(4 <= 5)   // true
println(4 >= 5)   // false

注意：
1. 关系运算符的优先级低于算术运算符。
2. 关系运算符的优先级高于赋值运算符。

区间运算符（a..b）

区间运算符，顾名思义就是可以用来表示两个操作数之间的范围集合。a..b也就我们平时所说的，从a到b所有的数字集合。在Kotlin语言之中，有两种区间运算符：闭区间运算符和开区间运算符。
- 闭区间运算符 ： “a..b”从a到b范围内所有的值，包括a和b。
- 半闭区间运算符 ： “a until b”从a到b范围内所有的值，包括a和不包括b。

区间表达式由具有操作符形式 “..” 或 rangeTo 辅以 in 和 !in 而得。区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例：

for (i in 1..10) { // 等同于 1 <= i && i <= 10
    println(i)
}

for (i in 1.rangeTo(10)) {  // 等同于 1 <= i && i <= 10
    println(i)
}

for (i in 'a'..'z') { // 等同于 'a' <= i && i <= 'z'
    println(i)
}

in 代表在区间内，!in表示不在。

整型区间有一个额外的特性：它们可以迭代。 Kotlin编译器负责将其转换为类似 Java 的基于索引的 for循环而无额外开销。

for (i in 1..4) print(i) // 输出“1234”

for (i in 4..1) print(i) // 什么都不输出

运行上述例子，我们可以发现如果只写 “..”，这个区间值只是顺序。如果你想倒序迭代数字呢？也很简单。你可以使用标准库中定义的 downTo 方法：

for (i in 4 downTo 1) print(i) // 输出“4321”

能否以不等于 1 的任意步长迭代数字？ 当然没问题， 使用step方法就可以做到:

for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”

那么我们如何创建一个半闭区间呢？可以使用 until方法 ：

for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}

逻辑运算符

逻辑运算使用等式表示判断，把推理看做等式运算，这种变换的有效性不依赖人们对符号的解释，只依赖符号组合的变换。Kotlin语言和Java一样，支持三个标准逻辑运算符，逻辑与、逻辑或、逻辑非。

• && ： 逻辑与，可以理解为并且的意思.
• || ： 逻辑或，可以理解为或者的意思，也就是条件可以二取一
• ！ ： 逻辑非，取反

逻辑运算表达式中，操作数值的组合不同，整个表达式的值也不同。在这里我们给出一个逻辑运算的值搭配总结表：

a	b	a&&b	a||b	!a
false	false	false	false	true
true	false	false	true	false
false	true	false	true	true
true	true	true	true	false

空安全操作符（?、!!）

在Java开发的过程中遇到的最多的异常就是NullPointException（NPE），空异常的问题很多是不可预见的。一直以来，NullPointException空指针异常在开发中是最低级也最致命的问题。我们往往需要进行各种null的判断以试图去避免NPE的发生。在Kotlin语言中一切皆对象，出现NPE则是致命性的问题。所提，在Kotlin语言中提出了预先判空处理，为此引用了两个操作符：判空操作符“?”、 强校验“!!”操作符。

预定义，是否能容纳空（?）

在Kotlin中，类型系统区分一个引用可以容纳null，还是不能容纳null。 Kotlin中绝大部分的对象都是不能够容纳null的，例如，基础类型中的常规变量不能容纳null：

var a: String = "abc"
a = null // 编译错误

如果要允许为null，我们可以声明一个变量为可空字符串，需要在定义的类型后面紧跟一个问号 “?”，如上述例子则写作* String?*：

var b: String? = "abc"
b = null // 这样编译没问题

对于无法容纳null的类型，我们可以放心的对它的属性进行调用。

var a: String = "abc"
var aLength = a.length // 放心调用，a肯定不会为null

同样的操作，我们则不能够对b字符串进行操作，对于可能为空的类型进行操作，我们就必须判空。

判空（?）

在Kotlin语言中判断一个对象是否为空有两种方式，第一种就是如同Java语言一样，使用if-else进行判空；另一中就还是使用操作符 “?” 进行判断。

// 在Java语言中我们使用的判空方法。
if (b != null && b.length > 0) {
    println("String of length ${b.length}")
} else {
    println("Empty string")
}

// Kotlin，可空类型的判断
println("String of length ${b?.length}")

咋一看，差别不是很大，但，null安全，在链式调用中很有用。例如，如果一个员工 Bob 可能会（或者不会）分配给一个部门， 并且可能有另外一个员工是该部门的负责人，那么获取 Bob 所在部门负责人（如果有的话）的名字，我们写作：

bob?.department?.head?.name

如果任意一个属性（环节）为空，这个链式调用就会返回 null。如果要只对非空值执行某个操作，安全调用操作符可以与 let 一起使用：

val listWithNulls: List?> = listOf("A", null)
for (item in listWithNulls) {
     item?.let { println(it) } // 输出 A 并忽略 null
}

!! 操作符

很多情况下，NullPointerException对我们来说还是有一定意义的，我们必须catch住此异常。那么，Kotlin中的又有空安全的机制存在，我们就必须对null进行强校验。这里，Kotlin给我们提供的操作符为两个引号 “!!”，如：

var a : String? = null // 必须是可空类型，不然强校验没有意义
val lenC = a!!.length // 这样做就会报错

如果，希望强校验希望系统抛出一个NullPointerException，那么必须让定义的变量可容纳null，不然强校验就失去意义了。

安全的类型转换

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

val aInt: Int? = a as? Int

可空类型的集合

如果你有一个可空类型元素的集合，并且想要过滤非空元素，你可以使用 filterNotNull 方法来实现。

val nullableList: List?> = listOf(1, 2, null, 4)
val intList: List = nullableList.filterNotNull()

Elvis 操作符（?:）

Elvis操作符很像是Java语言中的三目表达式，然而由于三目表达式的对于很多开发者来说都比较难懂，导致经常用错。Kotlin对三目表达式进行了升级，即elvis表达式的来源，Kotlin中不再支持三目表达式。Elvis操作符的用法如下：

<结果> = <表达式1> ?: <表达式2>

如果表达式1为null，则返回表达式2的内容，否则返回表达式1。请注意，当且仅当左侧表达式1为空时，才会对右侧表达式求值。如：

// Elvis操作符获取b字符串的长度，如果b为null则返回-1
val lenB = b?.length ?: -1

// 等同于逻辑
val lenA: Int = if (b != null) {
    b.length
} else {
    -1
}

位运算符

运算符优先级

运算符的优先级使得一些运算符优先于其他运算符，从而是的高优先级的运算符会先被计算。而运算符的结合性用于定义相同优先级的运算符在一起的时和表达式结合或关联规则，在混合表达式中，运算符的优先级和结合性是非常重要的。如：

2 + 3 - 4 * 5 // 等于 -15

如果严格地从左到右，计算过程会是这样：

2 + 3 = 5
5 - 4 = 1
1 * 5 = 5

但实际上乘法优先于减法被计算，所以实际上的运算过程是：

2 + 3 = 5
4 * 5 = 20
5 - 20 = -15

这类似的情况和我们在数学中一样：右括号先算括号里的， 然后先乘除后加减。在Kotlin语言中也拥有自己运算符的优先级别和结合性。这里我们把所有的运算符总结为下表：

优先级	运算符	结核性
1	()、[]	从左到右
2	!、+(正)、-(负)、~、++、–	从右到左
3	*、/、%	从左到右
4	+(加)、-(减)	从左到右
5	<<、>>、>>>	从左到右
6	<、<=、>、>=	从左到右
7	==、!=	从左到右
8	&(按位与)	从左到右
9	^	从左到右
10	|	从左到右
11	&&	从左到右
12	||	从左到右
13	?:	从右到左
14	=、+=、-=、/=、%=、&=、|=、^=、~=、<<=、>>=、>>>=	从右到左

运算符重载

预定义的运算符的操作对象只能是基本数据类型，实际上，对于很多我们自定义的对象也需要有类似的运算操作。运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同类型的行为。

运算符重载是自C++语言器就支持的特性，然而在Java语言之中这个特性就不在支持，在很多高级科学运算上很不方便，Kotlin语言又从新支持此特性。不同于符合赋值运算符，我们可以定义/、==、-、+、*、%、<<、>>、！、&、|、^等运算符的逻辑功能。重载一个运算符，我们必须重写它所对应的operator方法，如下就是一个针对 “+” 运算符的定义：

public operator fun plus(other: Byte): Float

这里，我们可以看得出来运算符重载的实质是方法的重载。在实现过程中，首先把指定的运算表达式转化为对运算方法的调用，运算对象转化为运算符方法的实参，然后根据实参的类型来确定需要调用达标函数，之后Kotlin会将对应的符号运算切换到方法之中。如Float类型针对 “+” 运算符所定义的：

重载一元运算符

一元前缀操作符

表达式	转换方法
+a	a.unaryPlus()
-a	a.unaryMinus()
!a	a.not()

这个表是说，当编译器处理例如表达式 +a 时，它执行以下步骤：
1. 确定 a 的类型，令其为 T。
2. 为接收者 T 查找一个带有 operator 修饰符的无参函数 unaryPlus（），即成员函数或扩展函数。
3. 如果函数不存在或不明确，则导致编译错误。
4. 如果函数存在且其返回类型为 R，那就表达式 +a 具有类型 R。

递增和递减

表达式	转换方法
a++	a.inc()
a–	a.dec()

inc() 和 dec() 函数必须返回一个值，它用于赋值给使用 ++ 或 – 操作的变量。它们不应该改变在其上调用 inc() 或 dec() 的对象。

编译器执行以下步骤来解析后缀形式的操作符，例如 a++：
1. 确定 a 的类型，令其为 T。
2. 查找一个适用于类型为 T 的接收者的、带有 operator 修饰符的无参数函数 inc()。
3. 检查函数的返回类型是 T 的子类型。

计算表达式的步骤是：
1. 把 a 的初始值存储到临时存储 a0 中，
2. 把 a.inc() 结果赋值给 a，
3. 把 a0 作为表达式的结果返回。
4. 对于 a–，步骤是完全类似的。

对于前缀形式 ++a 和 –a 以相同方式解析，其步骤是：
1. 把 a.inc() 结果赋值给 a，
2. 把 a 的新值作为表达式结果返回。

二元操作符

算术运算符

表达式	转换方法
a + b	a.plus(b)
a - b	a.minus(b)
a * b	a.times(b)
a / b	a.div(b)
a % b	a.mod(b)
a..b	a.rangeTo(b)

对于此表中的操作，编译器只是解析成翻译为列中的表达式。

请注意，自 Kotlin 1.1 起支持 rem 运算符。Kotlin 1.0 使用 mod 运算符，它在 Kotlin 1.1 中被弃用。

“In”操作符

表达式	转换方法
a in b	b.contains(a)
a !in b	!b.contains(a)

对于 in 和 !in，过程是相同的，但是参数的顺序是相反的。

索引访问操作符

表达式	转换方法
a[i]	a.get(i)
a[i, j]	a.get(i, j)
a[i_1, …, i_n]	a.get(i_1, … , i_n)
a[i]=b	a.set(i, b)
a[i,j]=b	a.set(i, j, b)
a[i_1, … , i_n]=b	a.set(i_1,… ,o_n,b)

方括号转换为调用带有适当数量参数的 get 和 set。

调用操作符

表达式	转换方法
a(i)	a.invoke(i)
a(i, j)	a.invoke(i, j)
a(i_1, … , i_n)	a.invoke(i_1, …, i_n)

圆括号转换为调用带有适当数量参数的 invoke。

广义赋值

表达式	转换方法
a += b	a.plusAssign(b)
a -= b	a.minusAssign(b)
a *= b	a.timesAssign(b)
a /= b	a.divAssign(b)
a %= b	a.modAssign(b)

对于赋值操作，例如 a += b，编译器执行以下步骤：
1. 如果右列的函数可用
2. 如果相应的二元函数（即 plusAssign() 对应于 plus()）也可用，那么报告错误（模糊）。
3. 确保其返回类型是 Unit，否则报告错误。
4. 生成 a.plusAssign(b) 的代码
5. 否则试着生成 a = a + b 的代码（这里包含类型检查：a + b 的类型必须是 a 的子类型）。

注意：赋值在 Kotlin 中不是表达式。

相等与不等操作符

表达式	转换方法
a == b	a?.equals(b) ?: (b === null)
a != b	!(a?.equals(b) ?: (b === null))

这个 == 操作符有些特殊：它被翻译成一个复杂的表达式，用于筛选 null 值。 null == null 总是 true，对于非空的 x，x == null 总是 false 而不会调用 x.equals()。

注意：=== 和 !==（同一性检查）不可重载。

比较操作符

表达式	转换方法
a > b	a.compareTo(b) > 0
a < b	a.compareTo(b) < 0
a >= b	a.compareTo(b) >= 0
a <= b	a.compareTo(b) <= 0

所有的比较都转换为对 compareTo 的调用，这个函数需要返回 Int 值。

位运算

对于位运算，Kotlin 并没有提供特殊的操作符， 只是提供了可以叫中缀形式的方法， 比如：

// 给 Int 定义扩展
infix fun Int.shl(x: Int): Int {
……
}

// 用中缀表示法调用扩展方法
1 shl 2

// 等同于这样
1.shl(2)

下面是全部的位运算操作符(只可以用在 Int 和 Long 类型)：

表达式	转换方法
shl(bits)	有符号左移 (相当于Java <<)
shr(bits)	有符号右移 (相当于Java >>)
ushr(bits)	无符号右移(相当于Java >>>)
and(bits)	按位与
or(bits)	按位或
xor(bits)	按位异或
inv()	按位取反

---