In the previous article, you learned how to create variables and what are various basic data types available in Kotlin for creating variables.
In this article, you’ll learn what are various operators provided by kotlin to perform operations on basic data types.
Operations on Numeric Types
Just like other languages, Kotlin provides various operators to perform computations on numbers 
 Arithmetic operators (
+
,
,*
,/
,%
)  Comparison operators (
==
,!=
,<
,>
,<=
,>=
)  Assignment operators (
+=
,=
,*=
,/=
,%=
)  Increment & Decrement operators (
++
,
)
Following are few examples that demonstrate the usage of above operators 
var a = 10
var b = 20
var c = ((a + b) * ( a + b))/2 // 450
var isALessThanB = a < b // true
a++ // a now becomes 11
b += 5 // b equals to 25 now
Understanding how operators work in Kotlin
Everything in Kotlin is an object, even the basic data types like Int
, Char
, Double
, Boolean
etc. Kotlin doesn’t have separate primitive types and their corresponding boxed types like Java.
Note that Kotlin may represent basic types like Int
, Char
, Boolean
etc. as primitive values at runtime to improve performance, but for the end users, all of them are objects.
Since all the data types are objects, the operations on these types are internally represented as function calls.
For example, the addition operation a + b
between two numbers a
and b
is represented as a function call a.plus(b)

var a = 4
var b = 5
println(a + b)
// equivalent to
println(a.plus(b))
All the operators that we looked at in the previous section have a symbolic name which is used to translate any expression containing those operators into the corresponding function calls 
Expression  Translates to 

a + b  a.plus(b) 
a  b  a.minus(b) 
a * b  a.times(b) 
a / b  a.div(b) 
a % b  a.rem(b) 
a++  a.inc() 
a−−  a.dec() 
a > b  a.compareTo(b) > 0 
a < b  a.compareTo(b) < 0 
a += b  a.plusAssign(b) 
…  … 
You can check out other expressions and their corresponding function calls on Kotlin’s reference page.
The concept of translating such expressions to function calls enable operator overloading in Kotlin. For example, you can provide implementation for the plus
function in a class defined by you, and then you’ll be able to add the objects of that class using +
operator like this  object1 + object2
.
Kotlin will automatically convert the addition operation object1 + object2
into the corresponding function call object1.plus(object2)
(Think of a ComplexNumber
class with the +
operator overloaded).
You’ll learn more about operator overloading in a future article.
Note that the operations on basic types like Int
, Char
, Double
, Boolean
etc. are optimized and do not include the overhead of function calls.
Bitwise Operators
Unlike C, C++ and Java, Kotlin doesn’t have bitwise operators like 
(bitwiseor), &
(bitwiseand), ^
(bitwisexor), <<
(signed left shift), >>
(signed right shift) etc.
For performing bitwise operations, Kotlin provides following methods that work for Int
and Long
types 
shl
 signed shift left (equivalent of<<
operator)shr
 signed shift right (equivalent of>>
operator)ushr
 unsigned shift right (equivalent of>>>
operator)and
 bitwise and (equivalent of&
operator)or
 bitwise or (equivalent of
operator)xor
 bitwise xor (equivalent of^
operator)inv
 bitwise complement (equivalent of~
operator)
Here are few examples demonstrating how to use above functions 
1 shl 2 // Equivalent to 1.shl(2), Result = 4
16 shr 2 // Result = 4
2 and 4 // Result = 0
2 or 3 // Result = 3
4 xor 5 // Result = 1
4.inv() // Result = 5
All the bitwise functions, except inv()
, can be called using infix notation. The infix notation of 2.and(4)
is 2 and 4
. Infix notation allows you to write function calls in a more intuitive way.
Suggested Reading: Kotlin Infix Notation  Make function calls more intuitive
Operations on Boolean Types
Kotlin supports following logical operators for performing operations on boolean types 

 Logical OR&&
 Logical AND!
 Logical NOT
Here are few examples of logical operators 
2 == 2 && 4 != 5 // true
4 > 5 && 2 < 7 // false
!(7 > 12  14 < 18) // false
Logical operators are generally used in control flow statements like if
, ifelse
, while
etc., to test the validity of a condition.
Operations on Strings
String Concatenation
The +
operator is overloaded for String types. It performs String concatenation 
var firstName = "Rajeev"
var lastName = "Singh"
var fullName = firstName + " " + lastName // "Rajeev Singh"
String Interpolation
Kotlin has an amazing feature called String Interpolation. This feature allows you to directly insert a template expression inside a String. Template expressions are tiny pieces of code that are evaluated and their results are concatenated with the original String.
A template expression is prefixed with $
symbol. Following is an example of String interpolation 
var a = 12
var b = 18
println("Avg of $a and $b is equal to ${ (a + b)/2 }")
// Prints  Avg of 12 and 18 is equal to 15
If the template expression is a simple variable, you can write it like $variableName
. If it is an expression then you need to insert it inside a ${}
block.
Conclusion
That’s all folks! In this article, you learned what are various operators provided in Kotlin to perform operations on Numbers, Booleans, and Strings. You also learned how the expressions containing operators are translated to function calls internally.
As always, Thank you for reading.