In the previous article, you learned how to create variables and what are various basic data types available in Kotlin for creating variables.

In this article, you’ll learn what are various operators provided by kotlin to perform operations on basic data types.

## Operations on Numeric Types

Just like other languages, Kotlin provides various operators to perform computations on numbers –

- Arithmetic operators (
`+`

,`-`

,`*`

,`/`

,`%`

) - Comparison operators (
`==`

,`!=`

,`<`

,`>`

,`<=`

,`>=`

) - Assignment operators (
`+=`

,`-=`

,`*=`

,`/=`

,`%=`

) - Increment & Decrement operators (
`++`

,`--`

)

Following are few examples that demonstrate the usage of above operators –

```
var a = 10
var b = 20
var c = ((a + b) * ( a + b))/2 // 450
var isALessThanB = a < b // true
a++ // a now becomes 11
b += 5 // b equals to 25 now
```

### Understanding how operators work in Kotlin

Everything in Kotlin is an object, even the basic data types like `Int`

, `Char`

, `Double`

, `Boolean`

etc. Kotlin doesn’t have separate primitive types and their corresponding boxed types like Java.

*Note that Kotlin may represent basic types like Int, Char, Boolean etc. as primitive values at runtime to improve performance, but for the end users, all of them are objects.*

Since all the data types are objects, the operations on these types are internally represented as function calls.

For example, the addition operation `a + b`

between two numbers `a`

and `b`

is represented as a function call `a.plus(b)`

–

```
var a = 4
var b = 5
println(a + b)
// equivalent to
println(a.plus(b))
```

All the operators that we looked at in the previous section have a symbolic name which is used to translate any expression containing those operators into the corresponding function calls –

Expression | Translates to |
---|---|

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++ | a.inc() |

a−− | a.dec() |

a > b | a.compareTo(b) > 0 |

a < b | a.compareTo(b) < 0 |

a += b | a.plusAssign(b) |

… | … |

You can check out other expressions and their corresponding function calls on Kotlin’s reference page.

The concept of translating such expressions to function calls enable operator overloading in Kotlin. For example, you can provide implementation for the `plus`

function in a class defined by you, and then you’ll be able to add the objects of that class using `+`

operator like this – `object1 + object2`

.

Kotlin will automatically convert the addition operation `object1 + object2`

into the corresponding function call `object1.plus(object2)`

(Think of a `ComplexNumber`

class with the `+`

operator overloaded).

You’ll learn more about operator overloading in a future article.

*Note that the operations on basic types like Int, Char, Double, Boolean etc. are optimized and do not include the overhead of function calls.*

### Bitwise Operators

Unlike C, C++ and Java, Kotlin doesn’t have bitwise operators like `|`

(bitwise-or), `&`

(bitwise-and), `^`

(bitwise-xor), `<<`

(signed left shift), `>>`

(signed right shift) etc.

For performing bitwise operations, Kotlin provides following methods that work for `Int`

and `Long`

types –

`shl`

– signed shift left (equivalent of`<<`

operator)`shr`

– signed shift right (equivalent of`>>`

operator)`ushr`

– unsigned shift right (equivalent of`>>>`

operator)`and`

– bitwise and (equivalent of`&`

operator)`or`

– bitwise or (equivalent of`|`

operator)`xor`

– bitwise xor (equivalent of`^`

operator)`inv`

– bitwise complement (equivalent of`~`

operator)

Here are few examples demonstrating how to use above functions –

```
1 shl 2 // Equivalent to 1.shl(2), Result = 4
16 shr 2 // Result = 4
2 and 4 // Result = 0
2 or 3 // Result = 3
4 xor 5 // Result = 1
4.inv() // Result = -5
```

All the bitwise functions, except `inv()`

, can be called using infix notation. The infix notation of `2.and(4)`

is `2 and 4`

. Infix notation allows you to write function calls in a more intuitive way.

Kotlin supports following logical operators for performing operations on boolean types –

`||`

– Logical OR`&&`

– Logical AND`!`

– Logical NOT

Here are few examples of logical operators –

```
2 == 2 && 4 != 5 // true
4 > 5 && 2 < 7 // false
!(7 > 12 || 14 < 18) // false
```

Logical operators are generally used in control flow statements like `if`

, `if-else`

, `while`

etc., to test the validity of a condition.

## Operations on Strings

### String Concatenation

The `+`

operator is overloaded for String types. It performs String concatenation –

```
var firstName = "Rajeev"
var lastName = "Singh"
var fullName = firstName + " " + lastName // "Rajeev Singh"
```

### String Interpolation

Kotlin has an amazing feature called String Interpolation. This feature allows you to directly insert a *template expression* inside a String. Template expressions are tiny pieces of code that are evaluated and their results are concatenated with the original String.

A template expression is prefixed with `$`

symbol. Following is an example of String interpolation –

```
var a = 12
var b = 18
println("Avg of $a and $b is equal to ${ (a + b)/2 }")
// Prints - Avg of 12 and 18 is equal to 15
```

If the template expression is a simple variable, you can write it like `$variableName`

. If it is an expression then you need to insert it inside a `${}`

block.

## Conclusion

That’s all folks! In this article, you learned what are various operators provided in Kotlin to perform operations on Numbers, Booleans, and Strings. You also learned how the expressions containing operators are translated to function calls internally.

As always, Thank you for reading.