Operators are special characters which perform operation on operands (values or variable).There are various kind of operators available in Kotlin.

1) Arithmetic operator
2) Relation operator
3) Assignment operator
4) Arithmetic Assignment operator
5) Bitwise operation
6) Logical operator

  • Arithmetic Operator

    Arithmetic operators are used to perform basic mathematical operations such as addition (+), subtraction (-), multiplication (*), division (/) etc.

    Operator Description Expression Translate to
    + Addition a+b a.plus(b)
    - Substraction a-b a.minus(b)
    * Multiplication a*b a.times(b)
    / Division a/b a.div(b)
    % Modulus a%b a.rem(b)

    Example of Arithmetic Operator

    
    fun main(array: Array<String>) {
    
        //example of arithmetic operator
    
        var a: Int = 50
    
        var b: Int = 6
    
        var c: Int = a + b
    
        var d: Int = a - b
    
        var e: Int = a * b
    
        var f: Int = a % b
    
        var g: Int = a / b
    
        println("Addition : ${c}")
        println("Subtraction : ${d}")
        println("Multiplication : ${e}")
        println("Division : ${g}")
        println("Mod : ${f}")
    
        //it can also be done ...
        println("-----------------");
    
        var h = a.plus(b)
    
        var i = a.minus(b)
    
        var j = a.times(b)
    
        var k = a.div(b)
    
        var l = a.rem(b)
    
        println("Addition : ${h}")
        println("Subtraction : ${i}")
        println("Multiplication : ${j}")
        println("Division : ${k}")
        println("Mod : ${l}")
    
    
    }
    

    Output:
    Addition : 56
    Subtraction : 44
    Multiplication : 300
    Division : 8
    Mod : 2
    -----------------
    Addition : 56
    Subtraction : 44
    Multiplication : 300
    Division : 8
    Mod : 2
  • Relation Operator

    Relation operator shows the relation and compares between operands. Basically it is used to compare to operands .Following are the different relational operators:

    Operator Description Expression Translate to
    > greater than x > y a.compateTo(b)>0
    < Less than x < y a.compateTo(b)<0
    >= greater than or equal to x >= y a.compateTo(b)>=0
    <= less than or equal to x <= y a?.equals(b)?:(b===null)
    == is equal to x == y a?.equals(b)?:(b===null)
    != not equal to x != y !(a?.equals(b)?:(b===null))

    Example of Relational Operator

    
    fun main(array: Array<String>) {
        //example of relational operator
    
        var a: Int = 4
    
        var b: Int = 5
    
        println(a > b)
        println(a.compareTo(b) > 0)
    
        println(a == b)
        println(a.compareTo(b) == 0)
    }

    Output:
    false
    false
    false
    false
  • Assignment operator

    = is assignment operator which is used to assign the value to variable.

    Example)
    drag_handle
     fun main(array: Array<String>) {
        //example of assignment operator
    
        var name:String? = "Durgesh Kumar Tiwari"
    
        println("My name is ${name}")
    }
    Output:
    My name is Durgesh Kumar Tiwari
  • Arithmetic Assignment operator

    wherever Arithmetic and Assignment operator is used together for operation and assignment then these operator as known as Arithmetic Assignment Operator.
    for example

    += , -= ,*= , /=  etc


    Example of Relational Operator

    
    fun main(array: Array<String>) {
        
        //example of Arithmetic Assignment  operator
        var a: Int = 5
    
        var b: Int = 6
    
        a += b
    
        println("value of a is ${a}")
    }

    Output:
    value of a is 11
    
  • Logical Operator

    Logical operators are used to check conditions between operands. List of logical operators are given below.

    Operator Description Expression Convert to
    && return true if all expression are true (x > y) && (x > y) (x > y) and (x > y)
    || return true if any expression are true (x > y) || (x > y) (x > y) or (x > y)
    ! return complement of expression !x x.not()

    Example of Logical Operator

    fun main(array: Array<String>) {
    
        var flag: Boolean = true
    
        var flag1: Boolean = false
    
    
        var flag2: Boolean = true
    
    
        println(flag and flag1)
    
        println(flag or flag1)
    
        println(flag2.not())
    }

    Output:
    false
    true
    false
    
  • Bitwise Operation

    In Kotlin, there is not any special bitwise operator. Bitwise operation is done using named function.

    Example)
    drag_handle
         fun main(args: Array<String>){  
            var a=10  
            var b=2  
          
            println("a.shl(b): "+a.shl(b))  
            println("a.shr(b): "+a.shr(b))  
            println("a.ushr(b:) "+a.ushr(b))  
            println("a.and(b): "+a.and(b))  
            println("a.or(b): "+a.or(b))  
            println("a.xor(b): "+a.xor(b))  
            println("a.inv(): "+a.inv())  
          
        }  
    Output:
    a.shl(b): 40
    a.shr(b): 2
    a.ushr(b:) 2
    a.and(b): 2
    a.or(b): 10
    a.xor(b): 8
    a.inv(): -11

What next?

The next topic is Kotlin Tutorial

Share this page