Kotlin - Operators

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Kotlin is rich in built-in operators and provide the following types of operators:
Arithmetic Operators
Arithmetic Operators
Relational Operators
Relational Operators
Assignment Operators
Assignment Operators
Unary Operators
Unary Operators
Logical Operators
Logical Operators
Bitwise Operations
Bitwise Operations
Now let's look into these Kotlin Operators one by one.
Kotlin arithmetic operators are used to perform basic mathematical operations such as addition, subtraction, multiplication and division  etc.
Following example shows different calculations using Kotlin Arithmetic Operators:
fun main(args: Array<String>) {
   val x: Int = 40
   val y: Int = 20

   println("x + y = " +  (x + y))
   println("x - y = " +  (x - y))
   println("x / y = " +  (x / y))
   println("x * y = " +  (x * y))
   println("x % y = " +  (x % y))
}

When you run the above Kotlin program, it will generate the following output:
x + y = 60
x - y = 20
x / y = 2
x * y = 800
x % y = 0

Kotlin relational (comparison) operators are used to compare two values, and returns a Boolean value: either true or false.
Following example shows different calculations using Kotlin Relational Operators:
fun main(args: Array<String>) {
   val x: Int = 40
   val y: Int = 20

   println("x > y = " +  (x > y))
   println("x < y = " +  (x < y))
   println("x >= y = " +  (x >= y))
   println("x <= y = " +  (x <= y))
   println("x == y = " +  (x == y))
   println("x != y = " +  (x != y))
}

When you run the above Kotlin program, it will generate the following output:
x > y = true
x < y = false
x >= y = true
x <= y = false
x == y = false
x != y = true

Kotlin assignment operators are used to assign values to variables. 
Following is an example where we used assignment operator = to assign a values into two variables:
fun main(args: Array<String>) {
   val x: Int = 40
   val y: Int = 20
   
   println("x = " +  x)
   println("y = " +  y)
}

When you run the above Kotlin program, it will generate the following output:
x = 40
y = 20

Following is one more example where we used assignment operator += to add the value of self variable and assign it back into the same variable:
fun main(args: Array<String>) {
   var x: Int = 40

   x += 10
      
   println("x = " +  x)
}

When you run the above Kotlin program, it will generate the following output:
x = 50

Following is a list of all assignment operators:
Following example shows different calculations using Kotlin Assignment Operators:
fun main(args: Array<String>) {
   var x: Int = 40

   x += 5
   println("x += 5 = " + x )
   
   x = 40;
   x -= 5
   println("x -= 5 = " +  x)
   
   x = 40
   x *= 5
   println("x *= 5 = " +  x)
   
   x = 40
   x /= 5
   println("x /= 5 = " +  x)
   
   x = 43
   x %= 5
   println("x %= 5 = " + x)
}

When you run the above Kotlin program, it will generate the following output:
x += 5 = 45
x -= 5 = 35
x *= 5 = 200
x /= 5 = 8
x %= 5 = 3

The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an expression, or inverting the value of a boolean.
Following is the list of Kotlin Unary Operators:
Following example shows different calculations using Kotlin Unary Operators:
fun main(args: Array<String>) {
   var x: Int = 40
   var b:Boolean = true

   println("+x = " +  (+x))
   println("-x = " +  (-x))
   println("++x = " +  (++x))
   println("--x = " +  (--x))
   println("!b = " +  (!b))
}

When you run the above Kotlin program, it will generate the following output:
+x = 40
-x = -40
++x = 41
--x = 40
!b = false

Here increment (++) and decrement (--) operators can be used as prefix as ++x or --x as well as suffix as x++ or x--. The only difference between the two forms is that in case we use them as prefix then operator will apply before expression is executed, but if use them as suffix then operator will apply after the expression is executed.
Kotlin logical operators are used to determine the logic between two variables or values:
Following is the list of Kotlin Logical Operators:
Following example shows different calculations using Kotlin Logical Operators:
fun main(args: Array<String>) {
   var x: Boolean = true
   var y:Boolean = false

   println("x && y = " +  (x && y))
   println("x || y = " +  (x || y))
   println("!y = " +  (!y))
}

When you run the above Kotlin program, it will generate the following output:
x && y = false
x || y = true
!y = true

Kotlin does not have any bitwise operators but Kotlin provides a list of helper functions to perform bitwise operations.
Following is the list of Kotlin Bitwise Functions:
Following example shows different calculations using Kotlin bitwise functions:
fun main(args: Array<String>) {
   var x:Int = 60	  // 60 = 0011 1100  
   var y:Int = 13	  // 13 = 0000 1101
   var z:Int

   z = x.shl(2)       // 240 = 1111 0000
   println("x.shl(2) = " +  z)
   
   z = x.shr(2)       // 15 = 0000 1111
   println("x.shr(2) = " +  z)
   
   z = x.and(y)       // 12 = 0000 1100
   println("x.and(y)  = " +  z)
   
   z = x.or(y)        // 61 = 0011 1101
   println("x.or(y)  = " +  z)
   
   z = x.xor(y)       // 49 = 0011 0001
   println("x.xor(y)  = " +  z)
   
   z = x.inv()        // -61 = 1100 0011
   println("x.inv()  = " +  z)
}

When you run the above Kotlin program, it will generate the following output:
x.shl(2) = 240
x.shr(2) = 15
x.and(y)  = 12
x.or(y)  = 61
x.xor(y)  = 49
x.inv()  = -61

Q 1 - What does the Kotlin operator % do?
A - It is used to divide a number by another number.
B - Kotlin does not support any such operator
C - This is bitwise XOR operator
D - This is called modulus operator and returns the division remainder.
Given operator % is called Arithmetic Modulus operator and returns the remainder after dividing one number by another number.
Q 2 - Kotlin supports a good number of bitwise operators
A - Correct
B - Incorrect
This is incorrect statement because Kotlin does not provide any Bitwise operators, rather it provides a set of function to perform bitwise operations.
Q 3 - What does Kotlin operator ++ do?
A - It is used to add two values
B - There is no any such operators like ++ in Kotlin
C - This is called unary increment operator
D - None of the above
Given operator ++ is called unary increment operator in Kotlin
Q 4 - Which of the following function will do bitwise right shift operation?
A - x.ushr(y)
B - x.shr(y)
C - x.shl(y)
D - None of the above
Function x.shr(y) is used to shift the bits towards right by y times for a given x operand.
Q 5 - Which of the following is a logical inverse operator:
A - inv()
B - !
C - &&
D - ||
Yes operator ! is used to inverse the value of an operand.
Q 6 - What will be the output of the following Kotlin code:
fun main(args: Array<String>) {
   var x: Int = 40

   x += 10

   println(x)
}

A - 40
B - Syntax Error
C - 50
D None of the above
Here given operator += is addition assignment operator which mean it will be equvivalent to x = x + 10 which will yield a value of 50.
Q 7 - What will be the output of the following Kotlin code:
fun main(args: Array<String>) {
   var x: Int = 60

   println(x.shr(2))
}

A - 15
B - Syntax Error
C - 50
D None of the above
Correct value is 15 because x.shr(2) will shift x value by two places. So it x value is 60 = 0011 1100 , then after doing right shift it will give us 15 which is 0000 1111

    68 Lectures 
     4.5 hours 

 Arnab Chakraborty

    71 Lectures 
     5.5 hours 

 Frahaan Hussain

    18 Lectures 
     1.5 hours 

 Mahmoud Ramadan

    49 Lectures 
     6 hours 

 Catalin Stefan

    49 Lectures 
     2.5 hours 

 Skillbakerystudios

    22 Lectures 
     1 hours 

 CLEMENT OCHIENG
 Print
 Add Notes
 Bookmark this page