Operators are special symbols (characters) that carry out operations on operands (variables and values). For example, +
is an operator that performs addition.
In Java variables article, you learned to declare variables and assign values to variables. Now, you will learn to use operators perform various operations on them.
Here's a list of arithmetic operators in Kotlin:
Operator | Meaning |
---|---|
+ | Addition (also used for string concatenation) |
- | Subtraction Operator |
* | Multiplication Operator |
/ | Division Operator |
% | Modulus Operator |
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")
}
When you run the program, the output will be:
number1 + number2 = 16.0 number1 - number2 = 9.0 number1 * number2 = 43.75 number1 / number2 = 3.5714285714285716 number1 % number2 = 2.0
The +
operator is also used for the concatenation of String
values.
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)
}
When you run the program, the output will be:
Talk is cheap. Show me the code. - Linus Torvalds
Suppose, you are using +
arithmetic operator to add two numbers a and b.
Under the hood, the expression a + b
calls a.plus(b)
member function. The plus
operator is overloaded to work with String
values and other basic data types (except Char and Boolean).
// + 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
You can also use +
operator to work with user-defined types (like objects) by overloading plus()
function.
Recommended Reading: Kotlin Operator Overloading
Here's a table of arithmetic operators and their corresponding functions:
Expression | Function name | Translates to |
---|---|---|
a + b | plus | a.plus(b) |
a - b | minus | a.minus(b) |
a * b | times | a.times(b) |
a / b | div | a.div(b) |
a % b | mod | a.mod(b) |
Assignment operators are used to assign value to a variable. We have already used simple assignment operator =
before.
val age = 5
Here, 5 is assigned to variable age using =
operator.
Here's a list of all assignment operators and their corresponding functions:
Expression | Equivalent to | Translates to |
---|---|---|
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) |
fun main(args: Array<String>) {
var number = 12
number *= 5 // number = number*5
println("number = $number")
}
When you run the program, the output will be:
number = 60
Recommended Reading: Overloading assignment operators in Kotlin.
Here's a table of unary operators, their meaning, and corresponding functions:
Operator | Meaning | Expression | Translates to |
---|---|---|---|
+ | Unary plus | +a | a.unaryPlus() |
- | Unary minus (inverts sign) | -a | a.unaryMinus() |
! | not (inverts value) | !a | a.not() |
++ | Increment: increases value by1 | ++a | a.inc() |
-- | Decrement: decreases value by 1 | --a | a.dec() |
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")
}
When you run the program, the output will be:
-a = -1
!b = false
--c = 0
Recommended Reading: Overloading Unary Operators
Here's a table of equality and comparison operators, their meaning, and corresponding functions:
Operator | Meaning | Expression | Translates to |
---|---|---|---|
> | greater than | a > b | a.compareTo(b) > 0 |
< | less than | a < b | a.compareTo(b) < 0 |
>= | greater than or equals to | a >= b | a.compareTo(b) >= 0 |
<= | less than or equals to | a < = b | a.compareTo(b) <= 0 |
== | is equal to | a == b | a?.equals(b) ?: (b === null) |
!= | not equal to | a != b | !(a?.equals(b) ?: (b === null)) |
Comparison and equality operators are used in control flow such as if expression, when expression, and loops.
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")
}
When you run the program, the output will be:
b is larger than a. max = 12
Recommended Reading: Overloading of Comparison and Equality Operators in Kotlin
There are two logical operators in Kotlin: ||
and &&
Here's a table of logical operators, their meaning, and corresponding functions.
Operator | Description | Expression | Corresponding Function |
---|---|---|---|
|| | true if either of the Boolean expression is true |
(a>b)||(a<c) |
(a>b)or(a<c) |
&& | true if all Boolean expressions are true |
(a>b)&&(a<c) |
(a>b)and(a<c) |
Note that, or
and and
are functions that support infix notation.
Logical operators are used in control flow such as if expression, when expression, and loops.
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)
}
When you run the program, the output will be:
true
Recommended Reading: Overloading of Logical Operators in Kotlin
The in
operator is used to check whether an object belongs to a collection.
Operator | Expression | Translates to |
---|---|---|
in | a in b | b.contains(a) |
!in | 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.")
}
}
When you run the program, the output will be:
numbers array contains 4.
Recommended Reading: Kotlin in Operator Overloading
Here are some expressions using index access operator with corresponding functions in Kotlin.
Expression | Translated to |
---|---|
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) |
fun main(args: Array<String>) {
val a = intArrayOf(1, 2, 3, 4, - 1)
println(a[1])
a[1]= 12
println(a[1])
}
When you run the program, the output will be:
2 12
Recommended Reading: Kotlin Index access operator Overloading
Here are some expressions using invoke operator with corresponding functions in Kotlin.
Expression | Translated to |
---|---|
a() |
a.invoke() |
a(i) |
a.invoke(i) |
a(i1, i2, ..., in) |
a.inkove(i1, i2, ..., in) |
a[i] = b |
a.set(i, b) |
In Kotlin, parenthesis are translated to call invoke
member function.
Recommended Reading: Invoke Operator Overloading in Kotlin
Unlike Java, there are no bitwise and bitshift operators in Kotlin. To perform these task, various functions (supporting infix notation) are used:
shl
- Signed shift leftshr
- Signed shift rightushr
- Unsigned shift rightand
- Bitwise andor
- Bitwise orxor
- Bitwise xorinv
- Bitwise inversionVisit this page to learn more about Bitwise Operations in Kotlin.
Also, there is no ternary operator in Kotlin unlike Java.