Kotlin学习：操作符

1.算术运算符重载

表达式	翻译为
a + b	a.plus(b)
a - b	a.minus(b)
a * b	a.times(b)
a / b	a.div(b)
a % b	a.rem(b) 、 a.mod(b) （在 Kotlin 1.1 中被弃用）
a..b	a.rangeTo(b)

代码示例

fun main(args: Array<String>) {
    val number1 = 12.5
    val number2 = 3.5
    var result: Double
    result = number1 + number2
    println("number1 + number2 = $result")
    result = number1 - number2
    println("number1 - number2 = $result")
    result = number1 * number2
    println("number1 * number2 = $result")
    result = number1 / number2
    println("number1 / number2 = $result")
    result = number1 % number2
    println("number1 % number2 = $result")
}

输出：
number1 + number2 = 16.0
number1 - number2 = 9.0
number1 * number2 = 43.75
number1 / number2 = 3.5714285714285716
number1 % number2 = 2.0

+操作符也可以用于连接字符串
代码示例

fun main(args: Array<String>) {
    val start = "没说过!"
    val middle = "不是我! "
    val end = "别瞎说"
    val writer= "------鲁迅"
    val result = start + middle + end + writer
    println(result)
}

输出
没说过!不是我!别瞎说------鲁迅

2.赋值操作符

表达式	翻译为
a += b	a.plusAssign(b)
a -= b	a.minusAssign(b)
a *= b	a.timesAssign(b)
a /= b	a.divAssign(b)
a %= b	a.remAssign(b)、 a.modAssign(b) （在 Kotlin 1.1 中被弃用）

对于赋值操作符需要注意的是，当操作内容可变的对象时，在声明对象的时候不能使用var

data class Student(var age: Int) {
    operator fun plus(other: Student): Student{
        return Student(age + other.age)
    }
    operator fun plusAssign(other: Student) {
        age += other.age
    }
}
fun main() {
//    var s1 = Student(10) // 不能这样声明Student，否则执行 += 时会报错.
    val s1 = Student(10)
    val s2 = Student(11)
    s1 += s2
}

为什么使用 var 定义的 s1 会导致 += 报错呢？因为理论上，执行 += 时，既可以调用 s1 = s1 + s2，也就是 s1 = s1.plus(s2)，又可以调用 s1.plusAssign(s2)，都符合操作符重载约定，这样就会产生歧义，而如果使用 val 定义 s1，则只可能执行 s1.plusAssign(s2)，因为 s1 不可被重新赋值，因此 s1 = s1 + s2 这样的语法是出错的，永远不可能调用，那么调用 s1 += s2 就不会产生歧义了。

既然编译器会帮我把 a += b 解释成 a = a + b，那两者之间有何区别呢？

+(plus) 始终返回一个新的对象

+= (plusAssign) 用于内容可变的类型，修改对象自身的内容。

在kotlin的集合库中也有类似的实现

fun main() {
    val list = arrayListOf(1, 2)
    list += 3
    println("list=$list")
    val newList = list + 4
    println(println("newList=$newList"))
}
运行输出：
list=[1, 2, 3]
newList=[1, 2, 3, 4]

按住ctrl鼠标点击 进入源码

public inline operator fun <T> MutableCollection<in T>.plusAssign(element: T) {
    this.add(element)
}

代码很简单，直接调用了原集合的add()方法
用同样的方式点击

public operator fun <T> Collection<T>.plus(element: T): List<T> {
    val result = ArrayList<T>(size + 1)
    result.addAll(this)
    result.add(element)
    return result
}

代码同样很简单，只不过这次它是新建了一个集合，将原来的集合addAll(),然后再把element也加入新的集合里返回。

3.in操作符

表达式	翻译为
a in b	b.contains(a)
a !in b	!b.contains(a)

fun main(args: Array<String>) {
    val numbers = intArrayOf(1, 4, 42, -3)
    if (4 in numbers) {
        println("numbers array contains 4.")
    }
}
输出
numbers array contains 4.

in操作符也可以用于循环中

fun main(args: Array<String>) {
    val numbers = intArrayOf(1, 2, 3, 4)
    for(i in numbers) {
        print("$i ")
    }
}
输出
1 2 3 4

4. Invoke操作符

表达式	翻译为
a()	a.invoke()
a(arg)	a.invoke(arg)
a(arg_1,arg_2, ...,arg_n)	a.inkove(arg_1, arg_2, ..., arg_n)