# Kotlin Operators

Operators is an mathematical symbols or special characters. which are performed mathematically, logical and assignment operation in programming language. That is divided into 6 category in kotlin programming.

## Arithmetic operator

That is perform some basic mathematical operation like plus, minus, divide, multiply and remainder.

Operator Name
- Subtract (minus sign)
* Multiplication (* symbol)
/ Divide
% Remainder operator

For example.

``````//Example of Arithmetic operator
fun main(args: Array<String>) {
println(3+5)
//divide two double values
println(17.5-6.5)
//add one binary and integer values
println(0b01010 + 23)
//multiply value of two integers
println(3*2)
//divide value of two integers
println(7/3)
//modules of two integers
println(8%3)

}``````

#### Output

``````8
11.0
33
6
2
2
``````

## Relation operator

Relational operators are used to compare values and expression results.

Operator Name
> Greater than
< Less than
== Equal to equal to
>= Greater than equal to
<= Less than equal to
!= Not equal to

For example

``````//Example of Relation operator
fun main(args: Array<String>) {

if(6!=9){
println("6!=9")
}
else {
println("6==9")
}

val age:Int=20
//assign result to variable
var votingStatus=if(age>=18){
true
}else{
false
}
println(votingStatus)

}``````

#### Output

``````6!=9
true``````

## Assignment operator

Assignment operator are work on two operands. there is left operands is an variable. Which is used to stored the resultant of statements.

Operator Meaning
= Equal
*= Multiply and assign
/= Divide and assign
-= Subtract and assign
%= Calculate remainder and assign
``````//Example of Assignment operator
fun main(args: Array<String>) {

var num1:Int=4
var num2:Int=5
println("Before num1 = \$num1  num2 = \$num2")

num1+=num2 //same as num1=num1+num2

println("After (num1+=num2) : num1 = \$num1  num2 = \$num2")

num1=3
num2=2

println("Reset num1 = \$num1  num2 = \$num2")

num1-=num2 //same as num1=num1-num2
println("After (num1-=num2) : num1 = \$num1  num2 = \$num2")

num1=4
num2=7

println("Reset num1 = \$num1  num2 = \$num2")

num2*=num1 //same as num1=num1*num2
println("After (num2*=num1) : num1 = \$num1  num2 = \$num2")

num1=4
num2=3

println("Reset num1 = \$num1  num2 = \$num2")

num1%=num2 //same as num1=num1%num2
println("After (num1%=num1) : num1 = \$num1  num2 = \$num2")

num1=9
num2=3

println("Reset num1 = \$num1  num2 = \$num2")

num1/=num2 //same as num1=num1/num2
println("After (num1/=num1) : num1 = \$num1  num2 = \$num2")

}``````

#### Output

``````Before num1 = 4  num2 = 5
After (num1+=num2) : num1 = 9  num2 = 5
Reset num1 = 3  num2 = 2
After (num1-=num2) : num1 = 1  num2 = 2
Reset num1 = 4  num2 = 7
After (num2*=num1) : num1 = 4  num2 = 28
Reset num1 = 4  num2 = 3
After (num1%=num1) : num1 = 1  num2 = 3
Reset num1 = 9  num2 = 3
After (num1/=num1) : num1 = 3  num2 = 3
``````

## Bitwise operation

Operator Meaning
and Bitwise AND
or Bitwise OR
xor Bitwise XOR
inv() Bitwise complement(Bitwise inverse)
shl(bits) Signed shift left
shr(bits) Signed shift right
ushr(bits) Unsigned shift right

and : Bitwise and operators is working on logical value. When this operator are applied on two operands then this are work on its binary value. When there result are (1 and 1) their resultant is 1 (true). Otherwise 0.

``````//Example of Bitwise and
fun main(args: Array<String>) {

var data1:Int=7
var data2:Int=3
/*Logical and
*   7 = 0  1  1  1 (binary of 7)
*   3 = 0  0  1  1 (binary of 3)
and
--------------------------------
Result= 0  0  1   1 (binary of 3)
---------------------------------
Working :
1   1  = 1 (Both true then true)
0   1  = 0 (Any one false then false)

*/

println("data1.and(data2) = \${data1.and(data2)}")

//same as
println("(data1 and data2) = \${data1 and data2}")
}``````

#### Output

``````data1.and(data2) = 3
(data1 and data2) = 3
``````

bitwise or: When resultant binary is 0 or 0 then resultant is 0 otherwise resultant is 1. See this example.

``````//Example of Bitwise or
fun main(args: Array<String>) {

var data1:Int=7
var data2:Int=3
/*Bitwise or
*   7 = 0  1  1  1 (binary of 7)
*   3 = 0  0  1  1 (binary of 3)
or
--------------------------------
Result= 0  1  1   1 (binary of 3)
---------------------------------
Working :
0   0  = 0 (Both false then false)
0   1  = 0 (Any one true then true)

*/

println("data1.or(data2) = \${data1.or(data2)}")

//Same as
println("(data1 or data2) = \${data1 or data2}")
}``````

#### Output

``````data1.or(data2) = 7
(data1 or data2) = 7``````

bitwise xor: When resultant binary is (1 0) or (0 1) then resultant is 1 otherwise resultant is 0. See this example.

``````//Example of Bitwise xor
fun main(args: Array<String>) {

var data1:Int=15
var data2:Int=3
/*Bitwise xor
*    15 = 1  1  1  1 (binary of 15)
*   3 = 0  0  1  1 (binary of 3)
xor
--------------------------------
Result= 1  1  0  0 (binary of 12)
---------------------------------
Working :
1   0  = 1 (true)
0   1  = 1 (true)

Otherwise False
1   1  =0
0   0  =0

*/

println("data1.xor(data2) = \${data1.xor(data2)}")

//same as
println("(data1 xor data2) = \${data1 xor data2}")
}``````

#### Output

``````data1.xor(data2) = 12
(data1 xor data2) = 12``````

inv: Bitwise inverse example.

``````//Example of Bitwise inv
fun main(args: Array<String>) {

var data1:Int=15
var data2:Int=-6
/*Bitwise inv
Example 1:

15  = 1  1  1  1 (binary of 15)
+
--------------------------------
Result= 1  1  1  1 (binary of 16)
---------------------------------
output= - Result
output= - 16

Example 2: first remove that (- sign)
6   = 0  1  1  0 (binary of  6)
+
--------------------------------
Result= 0  1  0  1 (binary of 5)
Result= 5
Result =-5
---------------------------------
//multiply by (- sign)
output= - Result
output= - (-5)
output= 5

*/

println("data1.inv() = \${data1.inv()}")
println("data2.inv() = \${data2.inv()}")

}``````

#### Output

``````data1.inv() = -16
data2.inv() = 5``````

shl: Bitwise signed shift left example.

``````//Example of Bitwise shl
fun main(args: Array<String>) {

var data1:Int=15
var data2:Int=2
/*Bitwise shl
Example 1:

15        = 0  0  1  1  1  1 (binary of 15)
left shift 2  = 1  1  1  1  0  0

--------------------------------
60     =     1  1  1  1  0  0
---------------------------------
Or
Formula   = data * (2^ left shift)
example 1 =  15   *(2^2)  2 bit shift
=  15*4
=  60
example 2 =  2 *(2^5)
=  2 *(32)
=  64
*/

println("data1.shl(data2) = \${data1.shl(data2)}")
println("data2.shl(5) = \${data2.shl(5)}")

}``````

#### Output

``````data1.shl(data2) = 60
data2.shl(5) = 64
``````

shr(): Bitwise signed shift right example.

``````//Example of Bitwise shr
fun main(args: Array<String>) {

var data1:Int=15
var data2:Int=2
/*Bitwise shr
Example 1:

15        = 1  1  1  1 (binary of 15)
right shift 2 = 0  0  1  1

--------------------------------
3     =        0  0  1   1
---------------------------------
*/

println("data1.shr(data2) = \${data1.shr(data2)}") //3
println("data2.shr(1) = \${data2.shr(1)}") //1

}``````

#### Output

``````data1.shr(data2) = 3
data2.shr(1) = 1``````

ushr(): Bitwise unsigned shift right example.

``````//Example of Bitwise ushr
fun main(args: Array<String>) {

var data1:Int=8
var data2:Int=7
/*Bitwise ushr
Example 1:

8         = 1  0  0  0 (binary of 8)
right shift 3 = 0  0  0  1

--------------------------------
1     =      0  0  0   1
---------------------------------
*/

println("data1.ushr(2) = \${data1.ushr(2)}")
println("data2.ushr(1) = \${data2.ushr(1)}")

}``````

#### Output

``````data1.ushr(2) = 2
data2.ushr(1) = 3``````

## Logical operator

Operator Name
&& Logical AND operator.
|| Logical OR Operator
! Logical NOT Operator
``````//Example of Logical operator
fun main(args: Array<String>) {

var data1:Int=8
var data2:Int=7
var result:Boolean=true
println(!result) //false

//&& when check both condition is true
println(data1>data2 && result==true)//true

println(data2>data1 || result==true) //true (because second condition are valid)

}``````

#### Output

``````false
true
true``````

## Unary operator

This type of operators are work on single operand.

Operator Name
- Unary minus
++ Increment
-- Decrement
! not

Unary minus: This operator are modify argument sign of operand.

``````fun main(args: Array<String>) {
var a:Int=10
var b:Int=-20
print("Before a : \$a  b: \$b")
a=-a
b=-b
println("\nAfter  a : \$a  b: \$b")
}``````

#### Output

``````Before a : 10  b: -20
After  a : -10  b: 20``````

Increment (++): This are used to increment the variable value by one. This is two variant, prefix increment and postfix increment.

``````fun main(args: Array<String>) {
var testOne:Int=10
var testTwo:Int=10
var b:Int=testOne++ //postfix increment b=10
var c:Int=testOne //c=11
println("number :\$testOne")
println("b  :\$b")
println("c  :\$c")

b=++testTwo //prefix increment
c=testOne  //11
println("number :\$testTwo")
println("b  :\$b")
println("c  :\$c")
}``````

#### Output

``````number :11
b  :10
c  :11
number :11
b  :11
c  :11``````

prefix increment are first increment variable value, and after that use to variable values. Postfix increment are first use variable value, after that increment the variable value by one.

Decrement (--): This are used to decrement the variable value by one. This is two variant, prefix decrement and postfix decrement.

``````fun main(args: Array<String>) {
var info:Int=10
//prefix decrement
var  a:Int =--info //9
var  b:Int =info  //9
println("info :\$info")
println("a  :\$a")
println("b  :\$b")

info=10
//posfix decrement
a=info-- //10
b=info  //9
println("info :\$info")
println("a  :\$a")
println("b  :\$b")
}``````

#### Output

``````info :9
a  :9
b  :9
info :9
a  :10
b  :9``````

prefix decrement are first decrement variable value, and after that use to variable values. Postfix decrement are first use variable value, after that decrement the variable value by one.

not(!): This is logical operator, that are used to change boolean expression result value.

``````fun main(args: Array<String>) {
if(!true){
print("When Not true")
}else{
print("When true")
}
}``````

#### Output

``When true``

### Elvis operator kotlin

This operator are check first operands is not null then return first operand. otherwise returning other result.

``````fun main(args: Array<String>) {

var message:String ?=null
//if message not null then return message
//otherwise assign other value
message=message?: "Learn Kotlin"
println("Message : \$message")

}``````

#### Output

``Message : Learn Kotlin``

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.