Kotlin Operators

Operators are the symbols that operate on values to perform specific mathematical or logical computations on given values. They are the foundation of any programming language.

Example:

fun main(args: Array<String>) {
    var a= 10 + 20
    println(a)
}

Output:

30

Explanation: Here, ‘+‘ is an addition operator that adds 10 and 20 operands and returns the value 30 as a result.

Kotlin Operator Types

Kotlin operators are classified into 6 types based on the type of operation they perform:

Arithmetic Operators: 

Arithmetic operators are used to perform arithmetic or mathematical operations on the operands. For example, ‘+‘ is used for addition.

Example:

fun main(args: Array<String>)
{
    var a = 20 
    var b = 4 
    println("a + b = " + (a + b))
    println("a - b = " + (a - b))
    println("a * b = " + (a.times(b)))
    println("a / b = " + (a / b))
    println("a % b = " + (a.rem(b)))
}

Output:  

a + b = 24
a - b = 16
a * b = 80
a / b = 5
a % b = 0

 
Relational Operators:

Relational operators are used to compare the values of two operands. For example, ‘>’ checks whether the right operand is greater.

Example:

fun main(args: Array<String>)
{
    var c = 30
    var d = 40
    println("c > d = "+(c>d))
    println("c < d = "+(c.compareTo(d) < 0))
    println("c >= d = "+(c>=d))
    println("c <= d = "+(c.compareTo(d) <= 0))
    println("c == d = "+(c==d))
    println("c != d = "+(!(c?.equals(d) ?: (d === null))))
}

Output:  

c > d = false
c < d = true
c >= d = false
c <= d = true
c == d = false
c != d = true

Assignment Operators:

Assignment operators are used to assign a value to a variable. We assign the value of the right operand to left operand according to which assignment operator we use.  

Example:

fun main(args : Array<String>){
 var a = 10
    var b = 5
    a+=b
    println(a)
    a-=b
    println(a)
    a*=b
    println(a)
    a/=b
    println(a)
    a%=b
    println(a)

}

Output:  

​15
10
50
10
0

Unary Operators:

Unary Operators are used to increment or decrement a value.

Example:

fun main(args : Array<String>){
    var e=10
    var flag = true
    println("First print then increment: "+ e++)
    println("First increment then print: "+ ++e)
    println("First print then decrement: "+ e--)
    println("First decrement then print: "+ --e)
}

Output:  

First print then increment: 10
First increment then print: 12
First print then decrement: 12
First decrement then print: 10

Logical Operators:

Logical operators are used to combine two or more conditions or constraints, or to complement the evaluation of the original condition in consideration. The result returns a Boolean value, i.e., true or false.

Example:

fun main(args : Array<String>){
    var x = 100
    var y = 25
    var z = 10
    var result = false
    if(x > y && x > z)
     println(x)
    if(x < y || x > z)
     println(y)
    if( result.not())
     println("Logical operators")
}

Output:  

100
25
Logical operators

Bitwise Operators:

Bitwise operators work on bit-level. So, compiler first converted to bit-level and then the calculation is performed on the operands.

Example:

fun main(args: Array<String>)
{
    println("5 signed shift left by 1 bit: " + 5.shl(1))
    println("10 signed shift right by 2 bits: : " + 10.shr(2))
    println("12 unsigned shift right by 2 bits:  " + 12.ushr(2))
    println("36 bitwise and 22: " + 36.and(22))
    println("36 bitwise or 22: " + 36.or(22))
    println("36 bitwise xor 22: " + 36.xor(22))
    println("14 bitwise inverse is: " + 14.inv())
}

Output: 

5 signed shift left by 1 bit: 10
10 signed shift right by 2 bits: : 2
12 unsigned shift right by 2 bits:  3
36 bitwise and 22: 4
36 bitwise or 22: 54
36 bitwise xor 22: 50
14 bitwise inverse is: -15