Equality (== structural vs === referential) in Kotlin - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if two strings have the same content using structural equality.

Kotlin

val a = "hello"
val b = "hello"
println(a [1] b)

Drag options to blanks, or click blank then click option'

Aequals

B===

C!=

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using === instead of == for content comparison.

In Kotlin, == checks if two objects have the same content (structural equality).

2fill in blank

medium

Complete the code to check if two string variables point to the exact same object using referential equality.

Kotlin

val x = "world"
val y = x
println(x [1] y)

Drag options to blanks, or click blank then click option'

A===

B==

Cequals

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using == instead of === to check reference equality.

The === operator checks if two references point to the same object (referential equality).

3fill in blank

hard

Fix the error in the code to correctly compare two different String objects for content equality.

Kotlin

val s1 = String(charArrayOf('k', 'o', 't', 'l', 'i', 'n'))
val s2 = String(charArrayOf('k', 'o', 't', 'l', 'i', 'n'))
println(s1 [1] s2)

Drag options to blanks, or click blank then click option'

A===

Bequals()

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using === instead of == for content comparison.

Use == to compare the content of two different String objects in Kotlin.

4fill in blank

hard

Fill both blanks to create a map of words to their lengths, but only include words with length greater than 3.

Kotlin

val words = listOf("cat", "kotlin", "dog", "java")
val lengths = words.associateWith { it.[1] }
val filtered = lengths.filter { it.value [2] 3 }

Drag options to blanks, or click blank then click option'

Alength

B>

C<

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > in the filter condition.

Use length to get the length of each word, and filter with > to keep words longer than 3.

5fill in blank

hard

Fill all three blanks to create a map of uppercase words to their lengths, including only words with length greater than 3.

Kotlin

val words = listOf("apple", "bat", "carrot", "dog")
val result = words.associate { it.[1]() to it.[2] }
val filtered = result.filter { it.value [3] 3 }

Drag options to blanks, or click blank then click option'

Auppercase

Blength

C>

DtoUpperCase

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'uppercase' property instead of 'toUpperCase()' function.

Use toUpperCase() to convert words to uppercase, length for their length, and > to filter lengths greater than 3.

Practice

1. In Kotlin, what does the operator == check when comparing two variables?

easy

A. If the two variables are the exact same object (referential equality)

B. If the two variables have the same content (structural equality)

C. If the two variables are of the same type

D. If the two variables are both null

Solution

1. Step 1: Understand the meaning of == in Kotlin

   The == operator checks if two variables have the same content, meaning their values are equal.

2. Step 2: Differentiate from ===

   The === operator checks if two variables point to the exact same object in memory, which is different from ==.

3. Final Answer:

   If the two variables have the same content (structural equality) -> Option B

4. Quick Check:

   == means structural equality [OK]

Hint: Remember: == compares values, not object identity [OK]

Common Mistakes:

• Confusing == with ===
• Thinking == checks object identity
• Assuming == checks type equality

2. Which of the following Kotlin expressions correctly checks if two variables refer to the exact same object?

easy

A. a === b

B. a != b

C. a.equals(b)

D. a == b

Solution

1. Step 1: Identify the operator for referential equality

   In Kotlin, === checks if two variables point to the exact same object in memory.

2. Step 2: Confirm other options

   == and .equals() check structural equality, and != checks inequality, so they don't check referential equality.

3. Final Answer:

   a === b -> Option A

4. Quick Check:

   === means referential equality [OK]

Hint: Use === to check if two variables are the same object [OK]

Common Mistakes:

• Using == instead of === for object identity
• Confusing .equals() with ===
• Assuming != checks referential equality

3. What will be the output of the following Kotlin code?

val a = "hello"
val b = String(charArrayOf('h', 'e', 'l', 'l', 'o'))
println(a == b)
println(a === b)

medium

A. true\nfalse

B. false\nfalse

C. true\ntrue

D. false\ntrue

Solution

1. Step 1: Evaluate a == b

   Both strings contain the same characters "hello", so a == b is true because it checks structural equality.

2. Step 2: Evaluate a === b

   They are two different String objects in memory, so a === b is false because it checks referential equality.

3. Final Answer:

   true\nfalse -> Option A

4. Quick Check:

   == true, === false [OK]

Hint: == checks content, === checks if same object [OK]

Common Mistakes:

• Assuming === is true because contents match
• Confusing == with ===
• Thinking different objects with same content are ===

4. Consider this Kotlin code snippet:

val x = listOf(1, 2, 3)
val y = listOf(1, 2, 3)
if (x === y) {
    println("Same object")
} else {
    println("Different objects")
}

What is the output and why?

medium

A. Same object

B. Compilation error

C. Different objects

D. Runtime exception

Solution

1. Step 1: Understand listOf creates new objects

   Each call to listOf(1, 2, 3) creates a new list object, so x and y are different objects.

2. Step 2: Check referential equality with ===

   Since x and y are different objects, x === y is false, so the else branch runs.

3. Final Answer:

   Different objects -> Option C

4. Quick Check:

   === false for different list objects [OK]

Hint: listOf creates new objects; === checks identity [OK]

Common Mistakes:

• Assuming lists with same content are ===
• Confusing structural and referential equality
• Expecting compilation or runtime errors

5. You want to check if two variables a and b in Kotlin either have the same content or are the exact same object. Which code snippet correctly prints "Equal" if either condition is true, and "Not Equal" otherwise?

hard

A. if (a === b) {
println("Equal")
} else if (a == b) {
println("Not Equal")
} else {
println("Equal")
}

B. if (a === b && a == b) {
println("Equal")
} else {
println("Not Equal")
}

C. if (a == b) {
println("Not Equal")
} else if (a === b) {
println("Equal")
} else {
println("Not Equal")
}

D. if (a == b || a === b) {
println("Equal")
} else {
println("Not Equal")
}

Solution

1. Step 1: Understand the condition needed

   We want to print "Equal" if either a == b (same content) OR a === b (same object) is true.

2. Step 2: Check each option's logic

   if (a == b || a === b) {
       println("Equal")
   } else {
       println("Not Equal")
   }

   uses logical OR (||) correctly.

   if (a === b && a == b) {
       println("Equal")
   } else {
       println("Not Equal")
   }

   requires both to be true (AND), which is too strict.

   if (a == b) {
       println("Not Equal")
   } else if (a === b) {
       println("Equal")
   } else {
       println("Not Equal")
   }

   incorrectly prints "Not Equal" when a == b is true.

   if (a === b) {
       println("Equal")
   } else if (a == b) {
       println("Not Equal")
   } else {
       println("Equal")
   }

   prints "Not Equal" incorrectly when a == b is true but a === b is false.

3. Final Answer:

   if (a == b || a === b) -> Option D

4. Quick Check:

   Use || to combine == and === checks [OK]

Hint: Use || to check either structural or referential equality [OK]

Common Mistakes:

• Using && instead of ||
• Confusing order of conditions
• Printing wrong messages for conditions