# Operators

Kotlin provides all standard operators to build expression.

Unlike Java, some statements can be used as operator that returns last value:

*if else**when**try catch*

Most operators are implemented as methods of the corresponding types. Thus, you can use operators in * infix* notation as usual or as methods.

```
// val orResult = num1.or(num2)
val orResult = num1 or num2
```

Kotlin allows you to provide custom implementations for the predefined set of operators using overloading.

To implement an operator, provide a member function or an extension function with a __specific name__ and the operator modifier for the corresponding type.

## unary operators

+, -, ++ (increases value by 1), -- (decreases value by 1), ! (invert boolean value)

```
val x = 1
val y = 1
val b = true
println(++x)
println(y++)
println(!b)
```

The postfix “++” operator, first returns the current value and then increases the value.

The prefix “++” operator, first increases the value and then returns the newly incremented value.

Similarly for "--" operator.

To overload unary operators use following methods:

*unaryPlus*- for unary +*unaryMinus*- for unary -*not*- for !*inc*- for ++*dec*- for --

## arithmetic operators

+, -, *, /, % (remainder of division), .. (range from a to b)

The + operator is also used for the concatenation of String values.

To overload arithmetic operators use following methods:

*plus*- for binary +*minus*- for binary -*times*- for **div*- for /*rem*- for % (remainder of division)*rangeTo*- for .. (range from a to b)

```
var z = x + y // or x.plus(y)
var rangeAB = a..b // or a.rangeTo(b)
```

## assignment operators

=, +=, -=, *=, /=, %=

To overload assignment operators use following methods:

- Kotlin does not support overriding the
*=*operator *plusAssign*- for binary +=*minusAssign*- for binary -=*timesAssign*- for *=*divAssign*- for /=*remAssign*- for %=

Assignments are **not** expressions in Kotlin, i.e. don't generate result.

## comparison operators

*<**>**<=*- less than or equal to*>=*- greater than or equal to*!=*- not equal*==*- equal

To overload comparison operators use following methods:

*compareTo*- for <, >, <=, >=*equals*- for ==, !=

The identity equals operator === checks whether the operands point to the same object. Operator can’t be overloaded.

Similarly operator !== checks whether the operands point to the different objects. Operator can’t be overloaded.

## logic operators

*&&*logical and, returns true if both statements are true*||*logical or, returns true if one of the statements is true*!*- logical not, inverts boolean value

You can not overload || and && operators.

## bitwise operators

Bitwise operators are used on following types:

*Int**Long*

```
val orResult = num1 or num2 // bitwise "or"
val andResult = num1 and num2 // bitwise "and"
val andResult = num1 xor num2 // bitwise "xor"
val orResult1 = num1.or(num2) // perform bitwise "or" via method
```

To overload bitwise operators use following methods:

*or**and**xor**inv*- bit inversion*shl*- shift bits into the low-order positions (i.e. left shift)*shr*- shift bits into the high-order positions, filling the leftmost bits with copies of the sign bit (i.e. right shift)*ushr*- shift bits into the high-order positions, filling the leftmost bits with zeros.

## null safety operators

Use ?: (Elvis operator) to check null value.

```
var l: Int = if (b != null) b.length else -1
// same as
l = b?.length ?: -1
```

Use ?. operator to specify that value can be null. Safe calls are useful in chains.

```
val a = "Kotlin"
val b: String? = null
println(b?.length)
println(a?.length) // Unnecessary safe call
// Returns null if any of the properties in it is null.
var name = bob?.department?.head?.name
```

Use the !! operator to indicate that a value cannot be null.

`val l = b!!.length`

## other operators

Use the get()/set() method to override the [] index operator. By default [] operator is implemented for arrays, lists and maps.

```
var item1 = a[i] // same as: a.get(i)
var item2 = b[i,j] // c b.get(i, j)
a[i] = v // same as: a.set(i, v)
b[i, j] = v // same as: b.set(i,j, v)
// similarly for n arguments
```

Use the contains() method to override the in operator. By default [] operator is implemented for collections.

```
a in b // same as: b.contains(a)
a !in b // same as: !b.contains(a)
```

Use the invoke() method to override the () operator.

```
a() // same as: a.invoke()
a(i) // same as: a.invoke(i)
// similarly for n arguments
```

## operator overloading

To implement an operator, provide a member function or an extension function with a __specific name__ for the corresponding type.

Mark the corresponding function with the operator modifier.

```
data class Point(val x: Int, val y: Int)
operator fun Point.unaryMinus() = Point(-x, -y)
val point = Point(10, 20)
fun main() {
println(-point) // prints "Point(x=-10, y=-20)"
}
```

&&, ||, ?:, ===, !== operators cannot be overloaded.