2.2 运算符
2.2.1：算术运算符
算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。
举例2.2.1.1:设置两个变量，a=3,b=2,如下表：
操作符 |
描述 |
举例 |
+ |
加法 - 相加运算符两侧的值 |
a + b 等于 5 |
- |
减法 - 左操作数减去右操作数 |
a - b 等于 1 |
* |
乘法 - 相乘操作符两侧的值 |
a * b 等于 6 |
/ |
除法 - 左操作数除以右操作数 |
a / b 等于 1 |
% |
取模 - 左操作数除以右操作数的余数 |
a %b 等于 1 |
++ |
自增: 操作数的值增加1( 注意：++在前，先相加再运算，++在后先运算后相加) |
a++ = 3 ++a=4 |
-- |
自减: 操作数的值减少1( --在前先相减再运算，--在后先运算后相减) |
a-- = 3 --a = 2 |
代码演示（和表内举例不同）：
fun main(args: Array<String>) {
var a:Int = 3
var b:Int = 2
println("a+b = "+(a+b))
println("a-b = "+(a-b))
println("a*b = "+(a*b))
println("a/b = "+(a/b))
println("a%b = "+(a%b))
println("a++ = "+(a++))
println("a = "+a)
println("++b = "+(++b))
println("a-- = "+(a--))
println("a = "+a)
println("--b = "+(--b))
}
打印结果：
a+b = 5
a-b = 1
a*b = 6
a/b = 1
a%b = 1
a++ = 3
a = 4
++b = 3
a-- = 4
a = 3
--b = 2
需要解释的是，a/b，是取得商，a%b是取得余数，a++,下一次运算a时才会计算，同样a—也是。
2.2.2：关系运算符
关系运算，学习过其它高级语言的都会多多少少了解到，无非就是大于小于等于之类的，我们看下Kotin关系运算都包含哪些，设置a=3，b=2如下表：
运算符 |
描述 |
举例 |
== |
检查如果两个操作数的值是否相等，如果相等则条件为真 |
（a == b）为假(非真) |
!= |
检查如果两个操作数的值是否相等，如果值不相等则条件为真 |
(a != b) 为真 |
> |
检查左操作数的值是否大于右操作数的值，如果是那么条件为真 |
（a> b）为真 |
< |
检查左操作数的值是否小于右操作数的值，如果是那么条件为真 |
（a < b）为假 |
>= |
检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真 |
（a> = b）为真 |
<= |
检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真 |
（a <= b）为假 |
代码演示：
fun main(args: Array<String>) {
var a:Int = 3
var b:Int = 2
println(a==b)
println(a!=b)
println(a>b)
println(a<b)
println(a>=b)
println(a<=b)
}
打印结果：
false
true
true
false
true
false
2.2.3：逻辑运算符
Kotlin的逻辑运算符和Java语言类似，比如我们设置布尔变量a为真，变量b为假,总结可以看下表：
操作符 |
描述 |
举例 |
&& |
称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真 |
（a && b）为假 |
|| |
称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真 |
（a || b）为真 |
! |
称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false |
!（a &&b）为真 |
代码演示：
fun main(args: Array<String>) {
var a: Boolean = true
var b: Boolean = false
println(a&&b)
println(a||b)
println(!(a && b))
}
打印结果：
false
true
true
2.2.4：赋值运算符
Kotlin赋值运算符和Java也基本类似，但比Java要少些，具体请看下表：
操作符 |
描述 |
举例 |
= |
简单的赋值运算符，将右操作数的值赋给左侧操作数 |
c = a + b将把a + b得到的值赋给c |
+= |
加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 |
c + = a等价于c = c + a |
-= |
减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 |
c - = a等价于c = c -a |
*= |
乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 |
c * = a等价于c = c * a |
/= |
除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 |
c / = a等价于c = c / a |
%= |
取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 |
c％= a等价于c = c％a |
代码演示：
fun main(args: Array<String>) {
var a:Int = 3
var b:Int = 2
var c:Int = 1
c=a+b
println(c)//输出结果为 5
c+=a //=>c=c+a => c = 5 + 3 输出结果为8
println(c)
c-=a //=>c=c-a => c = 8 - 3 输出结果为5
println(c)
c*=a //=>c=c*a => c = 5 * 3 输出结果为15
println(c)
c/=a //=>c=c/a => c = 15 / 3 输出结果为5
println(c)
c%=a //=>c=c%a => c = 5 % 3 输出结果为2
println(c)
}
打印结果：
5
8
5
15
5
2
2.2.5：位运算符
Kotlin中对于按位操作，和Java是有很大的差别的，Kotlin中没有特殊的字符，但是只能命名为可以以中缀形式调用的函数，下列是按位操作的完整列表(仅适用于整形（Int）和长整形（Long）)：
Ø shl(bits) => 有符号向左移 (类似Java的<<)
Ø shr(bits) => 有符号向右移 (类似Java的>>)
Ø ushr(bits) => 无符号向右移 (类似Java的>>>)
Ø and(bits) => 位运算符 and (同Java中的按位与)
Ø or(bits) => 位运算符 or (同Java中的按位或)
Ø xor(bits) => 位运算符 xor (同Java中的按位异或)
Ø inv() => 位运算符 按位取反 (同Java中的按位取反)
下面附上Kotlin中关于位操作符的源码：
/** Shifts this value left by [bits]. */
public infix fun shl(bitCount: Int): Int
/** Shifts this value right by [bits], filling the leftmost bits with copies of the sign bit. */
public infix fun shr(bitCount: Int): Int
/** Shifts this value right by [bits], filling the leftmost bits with zeros. */
public infix fun ushr(bitCount: Int): Int
/** Performs a bitwise AND operation between the two values. */
public infix fun and(other: Int): Int
/** Performs a bitwise OR operation between the two values. */
public infix fun or(other: Int): Int
/** Performs a bitwise XOR operation between the two values. */
public infix fun xor(other: Int): Int
/** Inverts the bits in this value. */
public fun inv(): Int
代码演示：
fun main(args: Array<String>) {
var a: Int = 8
var shla = a shl(2)
var shra = a shr(2)
var ushra = a ushr(2)
var anda = a and(2)
var ora = a or(2)
var xora = a xor(2)
var inva = a.inv()
println("shla => $shla \n " +
"shra => $shra \n " +
"ushra => $ushra \n " +
"anda => $anda \n " +
"ora => $ora \n " +
"xora => $xora \n " +
"inva => $inva")
}
打印结果：
shla => 32
shra => 2
ushra => 2
anda => 0
ora => 10
xora => 10
inva => -9
2.2.6：运算符优先级
当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题，在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。
例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。
再如，x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。
下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部：
类别 |
操作符 |
关联性 |
后缀 |
() [] . |
左到右 |
乘性 |
* /％ |
左到右 |
加性 |
+ - |
左到右 |
相等 |
== != |
左到右 |
逻辑与 |
&& |
左到右 |
逻辑或 |
|| |
左到右 |
赋值 |
= + = - = * = / =％| = |
从右到左 |