Operators in Kotlin
Tags: kotlin, android, operatorsinkotlin, tutorial
Published: 2022-08-07 12:12:00

In this blog we will cover:
- What are operators
- Types of operators
- Arithmetic Operators
- Increment and Decrement Operators
- Assignment Operators
- Logical Operators
- Bitwise Operators

![Operators in Kotlin](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fv1rbqiiqh28nsnjfdn9.png)
 

**What is an Operator?**
An operator, in computer programing, is a symbol that usually represents an action or process. These symbols were adapted from mathematics and logic.
Operators are the backbone of any program and they are used for everything from very simple functions like counting to complex algorithms like security encryption.

We have different types of operators
![Different types of operators](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cidskhas9cbuyzis6ags.png)
Now, we will go through each type of operator one by one.
**1.Arithmetic Operator:** _An operator that performs arithmetic operations on groups of variables and numbers is called_ **Arithmetic operator**.
```
fun main(){
    var a = 20 var b = 4 
        println("a + b = " + (a + b))
        println("a - b = " + (a - b))
        println("a * b = " + (a*b))
        println("a / b = " + (a / b))
        println("a % b = " + (a % b))
}
```
**Output:**
```
a + b = 24
a - b = 16
a * b = 80
a / b = 5
a % b = 0

```
You are familiar with all the operators because you use them in your daily life..but what does "%" this sign does?
This sign is called **modulo(%)**. 
OK, but what does it do?
The modulo division operator produces the remainder of an integer division. For example, If 5 and 2 are integers, then the expression: <br/>`5 % 2`<br/>produces the remainder when **5 is divided by 2**, which is **1** 

**2.Increment and Decrement Operators:** _The increment(++) and decrement operators(--) are important unary operators in Kotlin. Unary operators are those which are applied on a single operand. The increment operator increases the value of the variable by one and the decrement operator decreases the value of the variable by one._

Types of Increment Operators:

- Prefix Increment Operator: If you use the ++ operator as a prefix like: `++var`, the value of var is incremented by 1, then it returns the value.
```
fun main(){
    val num = 5
    println("num = "+ num++)//First the value of num is printed and then a1 increases by 1.
}
```
**Output:**
```
num = 5
```
- Postfix Increment Operator: If you use the ++ operator as a postfix like: `var++`, the original value of var is returned first, then var is incremented by 1.
```
fun main(){
    val num = 5
    println("num = "+ ++num) //First the value of a2 increases by 1 and then the new value of num is printed.
}
```
**Output:**
```
num = 6
```

**3.Assignment Operators:** _Assignment operators are used to assigning value to a variable. The left side operand of the assignment operator is a variable and right side operand of the assignment operator is a value. The value on the right side must be of the same data-type of the variable on the left side otherwise the compiler will raise an error._ Assignment operator return a Boolean Values.
Different types of assignment operators are shown below:
![Different types of assignment operators](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hmkzil03ou435djocmnf.png)
Here is the code for your better understanding.
```
fun main(){
	var c = 30
	var d = 40
	println("c > d = "+(c>d))
	println("c < d = "+(c<d))
	println("c >= d = "+(c>=d))
	println("c <= d = "+(c<=d))
	println("c == d = "+(c==d))
	println("c != d = "+(c!=d))
}

```
**Output:**
```
c > d = false
c < d = true
c >= d = false
c <= d = true
c == d = false
c != d = true
```
**4.Logical Operators:** _Logical operators are generally used for combining two or more relational statements. They return Boolean values. The logical operators are used primarily in the expression evaluation to make a decision. These operators allow the evaluation and manipulation of specific bits within the integer._

The types of Logical operators with their description are tabulated as follows -
![types of Logical operators](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ioha7e0k2okyrbm29cm8.png)
```
fun main(){
	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)
	}
}

```
**Output:**
```
100
25
```
**5.Bitwise Operators:**_The bitwise operators are the operators used to perform the operations on the data at the bit-level. When we perform the bitwise operations, then it is also known as bit-level programming. It consists of two digits, either 0 or 1. It is mainly used in numerical computations to make the calculations faster._ Bitwise and bit shift operators are used on only two integral types (Int and Long) to perform bit-level operations.

We have different types of bitwise operators in the Kotlin. The following is the list of the bitwise operators:

![different types of bitwise operators](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hf06hp1dk4elgudd221b.png)
- **or:** The `or` function compares corresponding bits of two values. If either of the bits is 1, it gives 1. If not, it gives 0. For example,
![example of or bitwise](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nga5bktx4zha8ytche2h.png)
Let's implement this in our code!
```
fun main() {

    val number1 = 12
    val number2 = 25
    val result: Int

    result = number1 or number2   // result = number1.or(number2)
    println(result)
}
```
**Output:**
```
29
```
- **and:** The `and` function compares corresponding bits of two values. If both bits are 1, it is evaluated to 1. If either of the bits is 0, it is evaluated to 0. For example,
![example of and bitwise](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6a84kuq7bj5f6i2ywvxs.png)
Let's implement this in our code!
```
fun main() {

    val number1 = 12
    val number2 = 25
    val result: Int

    result = number1 and number2   // result= number1.and(number2)
    println(result)
}
```
**Output:**
```
8
```
- **xor:** The `xor` function compares corresponding bits of two values. If corresponding bits are different, it gives 1. If corresponding bits are same, it gives 0. For example,
![example of xor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6r4tqk85yhmipf6bfs46.png)
 Let's implement this in our code!
```
fun main() {

    val number1 = 12
    val number2 = 25
    val result: Int

    result = number1 xor number2   // result= number1.xor(number2)
    println(result)
}
```
**Output:**
```
21
```
- **inv():** The `inv()` function inverts the bit pattern. It makes every 0 to 1, and every 1 to 0. For example,
![example of inv()](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/r0zyaed9delowy70ibwv.png)
 
Let's implement this in our code!
```
fun main() {

    val number = 35
    val result: Int

    result = number.inv()
    println(result)
}
```
**Output:**
```
-36
```
**Why are we getting output -36 instead of 220?**
It's because the compiler is showing 2's complement of that number; negative notation of the binary number. 

For any integer `n`, 2's complement of `n` will be `-(n+1)`.
The bitwise complement of 35 is 220 (in decimal). The 2's complement of 220 is -36. Hence, the output is -36 instead of 220.

- **shl:** The `shl` function shifts bit pattern to the left by certain number of specified bits, and zero bits are shifted into the low-order positions. For example,
![example of shl](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cfexd1j079mh4l1of9yh.png)
 
Let's implement this in our code!
```
fun main() {

    val number = 212

    println(number shl 1)
    println(number shl 0)
    println(number shl 4)
}
```
**Output:**
```
424
212
3392
```
- **shr:** The `shr` function shifts bit pattern to the right by certain number of specified bits. For example,
![example of shr](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q652l2oxpc7l2czmltpf.png)
 
 
Let's implement this in our code!
```
fun main() {

    val number = 212

    println(number shr 1)
    println(number shr 0)
    println(number shr 8)
}
```
**Output:**
```
106
212
0
```
- **ushr:** The `ushr` function shifts zero into the leftmost position. For example,
![example of ushr](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cfexd1j079mh4l1of9yh.png)
 
Let's implement this in our code!
```
fun main() {

    val number1 = 5
    val number2 = -5

    // Signed right shift
    println(number1 shr 1)

    // Unsigned right shift
    println(number1 ushr 1)

    // Signed right shift
    println(number2 shr 1)

    // Unsigned right shift
    println(number2 ushr 1)
}
```
**Output:**
```
2
2
-3
2147483645
```
Notice, how signed and unsigned right shift function works differently for 2's complement.

The 2's complement of `2147483645` is `3`.

These are they types of operators we have in Kotlin. Hope you understood them well as you will be using them on a regular basis as an android developer😊.

You have doubt in any part you can ask it in the discussion section.
Wanna connect? then connect with me on [LinkedIn](https://www.linkedin.com/in/amandeep-singh-452949246/)


![Thank You](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9facsecp3kserio0bek0.png)