Object Creation and Equality

When creating objects in Kotlin, you use a concise and straightforward syntax. Unlike Java, you do not need the new keyword. You simply call the class constructor directly. For example, if you have a class named Person, you can create an instance by writing val person = Person("Alice"). This approach makes object creation more readable and less verbose compared to Java.

Kotlin also introduces two distinct equality operators: == and ===. The == operator checks for structural equality, meaning it compares the contents of the objects by calling the equals() method under the hood. On the other hand, the === operator checks for referential equality—it returns true if both references point to the exact same object in memory.

Understanding the difference between these operators is crucial when transitioning from Java. In Java, == checks for reference equality, and .equals() checks for structural equality. Kotlin's == is more like Java's .equals(), while Kotlin's === is equivalent to Java's == for object references.

In the code above, you see how Kotlin distinguishes between structural and referential equality. The line personA == personB evaluates to true because both objects have the same property values and the data class automatically implements equals(). However, personA === personB is false, because they are two different instances in memory, even though their contents are the same. personA === personC is true, since personC is just another reference to the exact same object as personA.

When deciding which equality operator to use, consider whether you care about the contents of the objects or their identity in memory. Use == if you want to check if two objects are equal in value, similar to using equals() in Java. Use === if you need to know whether two references point to the same object, just like the == operator in Java when used with objects.