# Kotlin 运算符

> 原文： [https://www.programiz.com/kotlin-programming/operators](https://www.programiz.com/kotlin-programming/operators)

#### Kotlin 有一组运算符，可以执行算术，赋值，比较运算符等。 您将在本文中学习如何使用这些运算符。

运算符是对操作数（变量和值）进行运算的特殊符号（字符）。 例如，`+`是执行加法的运算符。

在 [Java 变量](/kotlin-programming/variable-types "Kotlin Variables")文章中，您学习了声明变量并为变量赋值。 现在，您将学习使用运算符对它们执行各种操作。

* * *

## 1.算术运算符

以下是 Kotlin 中的算术运算符列表：

Kotlin 算术运算符

| 运算符 | 含义 |
| --- | --- |
| `+` | 加法（也用于字符串连接） |
| `-` | 减法运算符 |
| `*` | 乘法运算符 |
| `/` | 除法运算符 |
| `%` | 模运算符 |

* * *

### 示例：算术运算符

```kt
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")
}

```

运行该程序时，输出为：

```kt
number1 + number2 = 16.0
number1 - number2 = 9.0
number1 * number2 = 43.75
number1 / number2 = 3.5714285714285716
number1 % number2 = 2.0
```

`+`运算符还用于`String`值的连接。

* * *

### 示例：字符串的连接

```kt
fun main(args: Array<String>) {

    val start = "Talk is cheap. "
    val middle = "Show me the code. "
    val end = "- Linus Torvalds"

    val result = start + middle + end
    println(result)
}
```

运行该程序时，输出为：

```kt
Talk is cheap. Show me the code. - Linus Torvalds
```

* * *

### 算术运算符实际上如何工作？

假设您正在使用`+`算术运算符将两个数字`a`和`b`相加。

在后台，表达式`a + b`调用`a.plus(b)`成员函数。`plus`运算符被重载以使用`String`值和其他基本数据类型（ [Char](/kotlin-programming/variable-types#char "Kotlin Char Type") 和[布尔](/kotlin-programming/variable-types#boolean "Kotlin Boolean Type")除外）。

```kt
// + operator for basic types
operator fun plus(other: Byte): Int
operator fun plus(other: Short): Int
operator fun plus(other: Int): Int
operator fun plus(other: Long): Long
operator fun plus(other: Float): Float
operator fun plus(other: Double): Double

// for string concatenation
operator fun String?.plus(other: Any?): String

```

您也可以通过重载`plus()`函数，使用`+`运算符处理用户定义的类型（如对象）。

**推荐阅读**： [Kotlin 运算符重载](/kotlin-programming/operator-overloading "Kotlin Operator Overloading")

这是算术运算符及其对应函数的表：

| 表达式 | 函数名称 | 转换为 |
| --- | --- | --- |
| `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)` |

* * *

## 2.赋值运算符

赋值运算符用于为变量赋值。 之前我们已经使用了简单的赋值运算符`=`。

```kt
val age = 5
```

在此，使用`=`运算符将 5 分配给变量`age`。

以下是所有赋值运算符及其对应函数的列表：

| 表达式 | 相当于 | 转化为 |
| --- | --- | --- |
| `a += b` | `a = a + b` | `a.plusAssign(b)` |
| `a -= b` | `a = a - b` | `a.minusAssign(b)` |
| `a *= b` | `a = a * b` | `a.timesAssign(b)` |
| `a /= b` | `a = a / b` | `a.divAssign(b)` |
| `a %= b` | `a = a % b` | `a.modAssign(b)` |

* * *

### 示例：赋值运算符

```kt
fun main(args: Array<String>) {
    var number = 12

    number *= 5   // number = number*5
    println("number  = $number")
}
```

运行该程序时，输出为：

```kt
number = 60
```

**推荐阅读**： *重载 Kotlin 中的赋值运算符*。

* * *

## 3.一元前缀和递增/递减运算符

这是一元运算符，它们的含义和相应函数的表：

| 运算符 | 含义 | 表达式 | 转换为 |
| --- | --- | --- | --- |
| `+` | 一元加 | `+a` | `a.unaryPlus()` |
| `-` | 一元减（反转符号） | `-a` | `a.unaryMinus()` |
| `!` | 否定（反转值） | `!a` | `a.not()` |
| `++` | 递增：值加 1 | `++a` | `a.inc()` |
| `--` | 递减：值减 1 | `--a` | `a.dec()` |

* * *

### 示例：一元运算符

```kt
fun main(args: Array<String>) {
    val a = 1
    val b = true
    var c = 1

    var result: Int
    var booleanResult: Boolean

    result = -a
    println("-a = $result")

    booleanResult = !b
    println("!b = $booleanResult")

    --c
    println("--c = $c")
}
```

运行该程序时，输出为：

```kt
-a = -1
!b = false
--c = 0
```

**推荐阅读**： *重载一元运算符*

* * *

## 4.比较和相等运算符

这是一张相等和比较运算符，它们的含义以及相应函数的表：

| 运算符 | 含义 | 表达式 | 转换为 |
| --- | --- | --- | --- |
| `>` | 大于 | `a > b` | `a.compareTo(b) > 0` |
| `<` | 小于 | `a < b` | `a.compareTo(b) < 0` |
| `>=` | 大于或等于 | `a >= b` | `a.compareTo(b) >= 0` |
| `<=` | 小于或等于 | `a <= b` | `a.compareTo(b) <= 0` |
| `==` | 等于 | `a == b` | `a?.equals(b) ?: (b === null)` |
| `!=` | 不等于 | `a != b` | `!(a?.equals(b) ?: (b === null))` |

`if`和`when`表达式，和循环在控制流中使用比较和相等运算符。

* * *

### 示例：比较和相等运算符

```kt
fun main(args: Array<String>) {

    val a = -12
    val b = 12

    // use of greater than operator
    val max = if (a > b) {
        println("a is larger than b.")
        a
    } else {
        println("b is larger than a.")
        b
    }

    println("max = $max")
}

```

运行该程序时，输出为：

```kt
b is larger than a.
max = 12

```

**推荐阅读**： *Kotlin 中比较和相等运算符的重载*

* * *

## 5.逻辑运算符

Kotlin 中有两个逻辑运算符：`||`和`&&`

这是逻辑运算符，它们的含义和相应函数的表。

| 运算符 | 描述 | 表达式 | 对应函数 |
| --- | --- | --- | --- |
| <code>&#124;&#124;</code> | 如果任一布尔表达式为`true`，则为`true` | `(a>b)&#124;&#124;(a<c)` | `(a>b)or(a<c)` |
| `&&` | 如果所有布尔表达式均为`true`，则为`true` | `(a>b)&&(a<c)` | `(a>b)and(a<c)` |

注意，`or`和`and`是支持[中缀表示法](https://en.wikipedia.org/wiki/Infix_notation)的函数。

`if`和`when`表达式，和循环在控制流中使用逻辑运算符。

* * *

### 示例：逻辑运算符

```kt
fun main(args: Array<String>) {

    val a = 10
    val b = 9
    val c = -1
    val result: Boolean

    // result is true is a is largest
    result = (a>b) && (a>c) // result = (a>b) and (a>c)
    println(result)
}
```

运行该程序时，输出为：

```kt
true
```

**推荐阅读**： *Kotlin 中逻辑运算符的重载*

* * *

## 6\. `in`运算符

`in`运算符用于检查对象是否属于集合。

| 运算符 | 表达式 | 转换为 |
| --- | --- | --- |
| `in` | `a in b` | `b.contains(a)` |
| `!in` | `a !in b` | `!b.contains(a)` |

* * *

### 示例：`in`运算符

```kt
fun main(args: Array<String>) {

    val numbers = intArrayOf(1, 4, 42, -3)

    if (4 in numbers) {
        println("numbers array contains 4.")
    }
}
```

运行该程序时，输出为：

```kt
numbers array contains 4.
```

**推荐阅读**： *运算符重载中的 Kotlin*

* * *

## 7.索引访问运算符

以下是在 Kotlin 中使用带有索引访问运算符和相应函数的一些表达式。

| 表达式 | 转换为 |
| --- | --- |
| `a[i]` | `a.get(i)` |
| `a[i, n]` | `a.get(i, n)` |
| `a[i1, i2, ..., in]` | `a.get(i1, i2, ..., in)` |
| `a[i] = b` | `a.set(i, b)` |
| `a[i, n] = b` | `a.set(i, n, b)` |
| `a[i1, i2, ..., in] = b` | `a.set(i1, i2, ..., in, b)` |

* * *

### 示例：索引访问运算符

```kt
fun main(args: Array<String>) {

    val a  = intArrayOf(1, 2, 3, 4, - 1)
    println(a[1])   
    a[1]= 12
    println(a[1])
}

```

运行该程序时，输出为：

```kt
2
12
```

**推荐阅读**： *Kotlin 索引访问运算符重载*

* * *

## 8.调用运算符

以下是在 Kotlin 中使用带有相应函数的调用操作符的一些表达式。

| 表达式 | 转换为 |
| --- | --- |
| `a()` | `a.invoke()` |
| `a(i)` | `a.invoke(i)` |
| `a(i1, i2, ..., in)` | `a.inkove(i1, i2, ..., in)` |

在 Kotlin 中，括号被翻译为调用`invoke`成员函数。

**推荐阅读**： *调用 Kotlin 中的运算符重载*

* * *

### 按位运算

与 Java 不同，Kotlin 中没有按位和移位运算符。 为了执行这些任务，使用了各种函数（支持中缀符号）：

*   `shl` - 符号左移
*   `shr` - 符号右移
*   `ushr` - 无符号右移
*   `and` - 按位和
*   `or` - 按位或
*   `xor` - 按位异或
*   `inv` - 按位反转

访问此页面以了解有关 Kotlin 中[按位运算的更多信息](/kotlin-programming/bitwise "Kotlin Bitwise Operations")。

* * *

另外，与 Java 不同，Kotlin 中没有三元运算符。