Operators
## Learning Objectives
- Master arithmetic operators
- Understand comparison and equality operators
- Learn logical operators
- Work with the `in` operator and ranges
## Arithmetic Operators
```kotlin
fun main() {
val a = 10
val b = 3
println("a + b = ${a + b}") // Addition: 13
println("a - b = ${a - b}") // Subtraction: 7
println("a * b = ${a * b}") // Multiplication: 30
println("a / b = ${a / b}") // Division: 3 (integer division)
println("a % b = ${a % b}") // Modulo: 1
// Floating point division
val result = a.toDouble() / b
println("a / b (float) = $result") // 3.333...
}
```
### Augmented Assignment Operators
```kotlin
fun main() {
var num = 10
num += 5
println(num) // 15
num -= 3
println(num) // 12
num *= 2
println(num) // 24
num /= 4
println(num) // 6
num %= 5
println(num) // 1
}
```
### Unary Operators
```kotlin
fun main() {
var a = 5
var b = -3
println("+a = ${+a}") // 5
println("-b = ${-b}") // 3
// Increment and decrement
var i = 0
println("i++ = ${i++}") // 0 (post-increment)
println("i = $i") // 1
var j = 0
println("++j = ${++j}") // 1 (pre-increment)
println("j = $j") // 1
}
```
## Comparison Operators
```kotlin
fun main() {
val a = 5
val b = 10
println("a > b = ${a > b}") // false
println("a < b = ${a < b}") // true
println("a >= b = ${a >= b}") // false
println("a <= b = ${a <= b}") // true
// Can compare different types that implement Comparable
println("'a' < 'b' = ${'a' < 'b'}") // true
println("\"apple\" < \"banana\" = ${"apple" < "banana"}") // true
}
```
## Equality Operators
```kotlin
fun main() {
// Structural equality (equals)
val a = 10
val b = 10
println("a == b = ${a == b}") // true
println("a != b = ${a != b}") // false
// String equality
val str1 = "hello"
val str2 = "hello"
println("str1 == str2 = ${str1 == str2}") // true
// Reference equality (identical)
val list1 = listOf(1, 2, 3)
val list2 = listOf(1, 2, 3)
println("list1 === list2 = ${list1 === list2}") // false
println("list1 == list2 = ${list1 == list2}") // true (same elements)
}
```
## Logical Operators
```kotlin
fun main() {
val a = true
val b = false
println("a && b = ${a && b}") // false (AND)
println("a || b = ${a || b}") // true (OR)
println("!a = ${!a}") // false (NOT)
}
```
### Short-circuit Evaluation
```kotlin
fun main() {
fun returnsFalse(): Boolean {
println("returnsFalse called")
return false
}
fun returnsTrue(): Boolean {
println("returnsTrue called")
return true
}
// Short-circuit: second operand not evaluated
println("AND with false:")
val andResult = returnsFalse() && returnsTrue()
println("\nOR with true:")
val orResult = returnsTrue() || returnsFalse()
}
```
## In Operator
### Checking Membership in Ranges
```kotlin
fun main() {
val num = 5
// In range (inclusive)
println("num in 1..10 = ${num in 1..10}") // true
println("num in 10..20 = ${num in 10..20}") // false
// Not in
println("num !in 1..3 = ${num !in 1..3}") // true
}
```
### Checking Membership in Collections
```kotlin
fun main() {
val fruits = listOf("apple", "banana", "cherry")
println("'apple' in fruits = ${"apple" in fruits}") // true
println("'orange' in fruits = ${"orange" in fruits}") // false
}
```
### Using with when Expressions
```kotlin
fun main() {
val grade = 85
val result = when (grade) {
in 90..100 -> "A"
in 80..89 -> "B"
in 70..79 -> "C"
in 60..69 -> "D"
else -> "F"
}
println("Grade: $result") // Grade: B
}
```
## Bitwise Operators
```kotlin
fun main() {
val a = 0b1100 // 12 in binary
val b = 0b1010 // 10 in binary
println("a and b = ${Integer.toBinaryString(a and b)}") // 1000
println("a or b = ${Integer.toBinaryString(a or b)}") // 1110
println("a xor b = ${Integer.toBinaryString(a xor b)}") // 0110
println("a shl 2 = ${Integer.toBinaryString(a shl 2)}") // 110000
println("a shr 1 = ${Integer.toBinaryString(a shr 1)}") // 110
println("a ushr 1 = ${Integer.toBinaryString(a ushr 1)}")// 110
println("inv a = ${Integer.toBinaryString(a.inv())}") // ...11110011
}
```
## Operator Precedence
```kotlin
fun main() {
// Operators from highest to lowest precedence:
// 1. Parentheses ()
// 2. Unary + - ! ~
// 3. Multiplicative * / %
// 4. Additive + -
// 5. Comparison < > <= >= in !in
// 6. Equality == != === !==
// 7. Logical AND &&
// 8. Logical OR ||
// 9. Assignment = += -= *= /= %=
val result = 2 + 3 * 4 // 14, not 20
println("2 + 3 * 4 = $result")
val result2 = (2 + 3) * 4 // 20
println("(2 + 3) * 4 = $result2")
}
```
## Summary
- Arithmetic: `+`, `-`, `*`, `/`, `%`
- Augmented: `+=`, `-=`, `*=`, `/=`, `%=`
- Comparison: `<`, `>`, `<=`, `>=`
- Equality: `==` (structural), `===` (reference)
- Logical: `&&`, `||`, `!`
- `in` checks membership in ranges and collections
- `!in` checks non-membership
- Bitwise: `and`, `or`, `xor`, `shl`, `shr`, `ushr`, `inv`
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →