Kotlin Comparison Operators

In Kotlin, comparison operators allow you to compare values, making decisions in your programs based on how these values relate to one another. These operators are essential for implementing conditional logic, whether it’s checking if one number is greater than another or determining whether two objects are equal.

In this article, we’ll explore the different types of comparison operators in Kotlin and provide real-world examples of how to use them. By the end, you’ll be comfortable using comparison operators to build decision-making logic in your Kotlin programs.

What Are Comparison Operators?

Comparison operators in Kotlin are used to compare two values. They return a Boolean result (true or false) based on the outcome of the comparison. Kotlin supports the following comparison operators:

• Equality (==)
• Inequality (!=)
• Greater than (>)
• Less than (<)
• Greater than or equal to (>=)
• Less than or equal to (<=)

Let’s explore each operator in detail.

1. Equality (==)

The equality operator (==) checks whether two values are equal. In Kotlin, this is different from Java’s ==, which checks for reference equality. In Kotlin, == checks for structural equality, meaning it checks if the content of the objects is the same.

Example:

fun main() {
    val a = 10
    val b = 10

    println(a == b)  // Output: true
}

In this example, both a and b have the same value (10), so the expression returns true.

2. Inequality (!=)

The inequality operator (!=) checks if two values are not equal. If the values are different, it returns true; otherwise, it returns false.

Example:

fun main() {
    val a = 10
    val b = 20

    println(a != b)  // Output: true
}

In this case, a and b have different values, so the inequality check returns true.

3. Greater Than (>)

The greater than operator (>) checks if the value on the left is greater than the value on the right.

Example:

fun main() {
    val a = 15
    val b = 10

    println(a > b)  // Output: true
}

Here, since a is greater than b, the expression returns true.

4. Less Than (<)

The less than operator (<) checks if the value on the left is less than the value on the right.

Example:

fun main() {
    val a = 5
    val b = 10

    println(a < b)  // Output: true
}

In this example, a is less than b, so the expression returns true.

5. Greater Than or Equal To (>=)

The greater than or equal to operator (>=) checks if the value on the left is greater than or equal to the value on the right. If either condition is true, the expression returns true.

Example:

fun main() {
    val a = 10
    val b = 10

    println(a >= b)  // Output: true
}

Since a is equal to b in this case, the expression evaluates to true.

6. Less Than or Equal To (<=)

The less than or equal to operator (<=) checks if the value on the left is less than or equal to the value on the right. If either condition is true, the expression returns true.

Example:

fun main() {
    val a = 5
    val b = 10

    println(a <= b)  // Output: true
}

Here, since a is less than b, the expression returns true.

Using Comparison Operators with if Statements

Comparison operators are frequently used in combination with if statements to make decisions in your programs. Let’s look at an example where we use multiple comparison operators within an if block.

Example:

fun main() {
    val age = 18

    if (age >= 18) {
        println("You are an adult.")
    } else {
        println("You are not an adult.")
    }
}

In this case, the program checks if the age is greater than or equal to 18. If it is, the program prints "You are an adult." Otherwise, it prints "You are not an adult."

Comparison with Different Data Types

You can use comparison operators with various data types, including numbers, strings, and characters.

Example with Strings:

Kotlin compares strings lexicographically, meaning it compares the Unicode values of each character in the string.

fun main() {
    val name1 = "Alice"
    val name2 = "Bob"

    println(name1 < name2)  // Output: true
}

In this example, "Alice" is considered lexicographically less than "Bob" because "A" comes before "B" in the Unicode table.

Example with Characters:

Kotlin also allows you to compare characters using their Unicode values.

fun main() {
    val char1 = 'A'
    val char2 = 'B'

    println(char1 < char2)  // Output: true
}

Real-World Use Case: Finding the Maximum of Three Numbers

Let’s implement a simple program that finds the maximum of three numbers using comparison operators.

fun main() {
    println("Enter first number:")
    val num1 = readLine()?.toIntOrNull()

    println("Enter second number:")
    val num2 = readLine()?.toIntOrNull()

    println("Enter third number:")
    val num3 = readLine()?.toIntOrNull()

    if (num1 != null && num2 != null && num3 != null) {
        val max = if (num1 >= num2 && num1 >= num3) {
            num1
        } else if (num2 >= num1 && num2 >= num3) {
            num2
        } else {
            num3
        }

        println("The maximum number is: $max")
    } else {
        println("Invalid input")
    }
}

In this program, the user enters three numbers, and the program uses comparison operators to determine the maximum value.

Comparison of Objects and Reference Equality

While the == operator checks for structural equality (content), Kotlin also provides the === operator, which checks for reference equality. This checks whether two references point to the same object in memory.

Example:

fun main() {
    val obj1 = "Hello"
    val obj2 = "Hello"
    val obj3 = obj1

    println(obj1 == obj2)  // true, because they have the same content
    println(obj1 === obj2)  // false, because they are different objects
    println(obj1 === obj3)  // true, because they point to the same object
}

In this example, obj1 and obj2 have the same content, so == returns true. However, since they are different objects in memory, === returns false. Meanwhile, obj1 === obj3 returns true because both references point to the same object.

Conclusion

Comparison operators in Kotlin are a fundamental part of building decision-making logic in your programs. By understanding and using these operators effectively, you can perform equality checks, compare values, and control the flow of your program based on different conditions.

• The equality operator (==) checks if two values are equal.
• The inequality operator (!=) checks if two values are not equal.
• Greater than (>) and less than (<) operators allow you to compare numerical values.
• Greater than or equal to (>=) and less than or equal to (<=) check for equality along with comparison.
• Use the === operator to check for reference equality when comparing objects.

Next up, we’ll explore logical operators in Kotlin and see how they can be used to combine multiple conditions and control complex decision-making logic in your programs. Stay tuned!