Kotlin语法基础,运算符

原创 2017年06月14日 20:21:39

运算符

计算机程序中最小的程序单位成为表达式,每个表达式都可以由两部分组成,即操作数和运算符。操作数可以是变量、常量、类、数组、方法等,甚至是其他表达式。而运算符则用于支出表达式中单个或者多个操作数参与运算的规则,表达式通过运算之后产生的值依赖于表达式中包含的运算符的优先级和结核性。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的源码如下:

image

故此,进行字符串与其他类型拼接我们都将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<String?> = 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<Int?> = listOf(1, 2, null, 4)
val intList: List<Int> = 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类型针对 “+” 运算符所定义的:
image

重载一元运算符

一元前缀操作符

表达式 转换方法
+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() 按位取反

版权声明:转载请标注:http://blog.csdn.net/yzzst 。 本文为博主原创文章,未经博主允许不得转载。作者:周圣韬(北漂周)

相关文章推荐

Kotlin常用操作符

1、kotlin 2、android 3、操作符
  • jhj_24
  • jhj_24
  • 2016年12月26日 17:25
  • 5102

Kotlin - 运算符重载

Kotlin支持标准的算术运算表达式, 其中运算符被声明为相应类的成员。Kotlin源代码中,我们可以自定义类型的运算符实现,即运算符的重载。这些运算符有固定的表示, 和固定的优先级。Kotlin为基...

Kotlin基本使用三

主要测试三目运算符,with调用类中多个方法,when,if表达式 package net.edaibu.kotlintest import java.io.File /** * Create...

Kotlin语法(三)基本类型

在Kotlin中,所有东西都是对象。 Numbers         Kotlin处理numbers和Java很接近,但是并不完全相同.例如, 对于numbers没有隐式扩大转换(如java中in...

【kotlin从入门到深坑】之语句

简介本篇博客主要是介绍Kotlin语法中的【语句】相关的知识,帮助各位更快的掌握Kotlin,如果有疏漏或者错误,请在留言中指正,谢谢。 系列汇总地址准备在学习之前我们先有点基础知识上的认识,如下: ...

你真的会用三目运算符吗?

写在前面: 三目运算符是我们经常在代码中使用的,a= (b==null?0:1); 这样一行代码可以代替一个 if-else,可以使代码变得清爽易读。但是,三目运算符也是有一定的语言规范...

js中两个等号(==)和三个等号(===)的区别

js中两个等号(==)和三个等号(===)的区别: 1. "=="表示:equality -> 等同  的意思,"=="使用两个等号时,如果两边值的类型不同的时候,是要先先进行类型转换后,才能做比较...
  • LeeJay5
  • LeeJay5
  • 2015年01月20日 14:21
  • 3195

Kotlin入门系列教程—运算符 字符 数组

Kotlin 的运算符 Kotlin支持标准的运算符比如 + - * / % 和JAVA一致的, 至于位运算,Kotlin 并没有提供特殊的操作符,只是提供了一些方法,比如 val ...

一周入门Kotlin(二)

本章主要介绍的内容有集合,运算符重载,控制流运算符等等。除了集合,你可以认为其他的内容比较杂和难运用,建议读者多多练习,不然哥也帮不了你! Kotlin主流集合框架 集合的框架分析 如果你想研...

高精度之乘法

题目描述 Description 给出两个正整数A和B,计算A*B的值。保证A和B的位数不超过500位。 输入描述 Input Description 读入两个用空格隔开...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Kotlin语法基础,运算符
举报原因:
原因补充:

(最多只允许输入30个字)