Nivel inicial13 min de lectura · Publicado el

Igualdad referencial (===) y estructural (==) en Kotlin

Igualdad en Kotlin: dos ejemplares iguales de una data class dan == true y === false; dos personas que señalan el mismo libro dan === true. ¿Iguales o el mismo objeto?rubentejera.com data class== true=== falsetúamigo=== true
Los dos ejemplares son una data class con los mismos datos: == compara el contenido y da true, pero === pregunta si son el mismo objeto y da false. Si tú y un amigo señaláis el mismo libro, === da true.

En Kotlin, == compara el contenido de dos objetos (llama a equals()) y ===, el triple igual, comprueba si dos referencias apuntan al mismo objeto. Imagina dos ejemplares del mismo libro: tienen el mismo contenido (== da true), pero no son el mismo libro (=== da false). Si le prestas tu ejemplar a un amigo y él dice «este es tu libro», los dos habláis del mismo objeto (=== da true).

En Kotlin existen dos tipos de igualdad:

Operador Nombre Pregunta Negación
== Igualdad estructural ¿Mismo contenido? (llama a equals()) !=
=== Igualdad referencial ¿Dos referencias apuntan al mismo objeto? !==

El ejemplo completo

class PersonaNormal(val name: String)

class PersonaConEquals(val name: String) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is PersonaConEquals) return false
        return name == other.name
    }

    override fun hashCode(): Int = name.hashCode()
}

data class PersonaData(val name: String, val age: Int)

fun main() {
    // Caso 1: tipos básicos
    val a = 5
    val b = 5
    println(a == b) // true

    // Caso 2: clase sin equals()
    val p1 = PersonaNormal("Ana")
    val p2 = PersonaNormal("Ana")
    println(p1 === p2) // false
    println(p1 == p2)  // false

    // Caso 3: clase con equals()
    val q1 = PersonaConEquals("Ana")
    val q2 = PersonaConEquals("Ana")
    println(q1 === q2) // false
    println(q1 == q2)  // true

    // Caso 4: data class
    val d1 = PersonaData("Ana", 27)
    val d2 = PersonaData("Ana", 27)
    val d3 = PersonaData("Pepe", 27)
    println(d1 === d2) // false
    println(d1 == d2)  // true
    println(d2 == d3)  // false
}

Caso 1: tipos básicos (Int, Double…)

Con los números, lo que importa es el valor, así que usa siempre ==.

En el original usábamos también a === b con dos Int, y daba true. La documentación explica por qué: para los valores que en tiempo de ejecución son tipos primitivos, como Int, === equivale a ==. Pero Kotlin desaconseja hacerlo y hoy el compilador avisa:

warning: identity equality for arguments of types 'Int' and 'Int' is deprecated.

Caso 2: objetos de una clase sin equals()

  • === compara las dos referencias: son dos objetos distintos, así que false.
  • == llama a equals(), pero la clase no lo ha sobrescrito. El equals() que hereda de Any compara referencias, así que también da false, aunque los dos tengan el mismo nombre.

Caso 3: una clase que sobrescribe equals() (override fun equals)

  • === sigue dando false: siguen siendo dos objetos.
  • == usa nuestro equals(), que compara el nombre, y da true.

El ejemplo original comparaba los nombres con other.name === this.name. Funcionaba por casualidad, porque en la JVM los textos literales iguales comparten el mismo objeto. Con un texto construido mientras se ejecuta el programa (por ejemplo, leído de un formulario), === da false aunque el contenido sea idéntico. Para comparar contenido, siempre ==.

Caso 4: data class

  • === sigue dando false.
  • == da true sin escribir nada: una data class genera automáticamente equals(), hashCode() y toString() a partir de las propiedades del constructor. Con d3, que tiene otro nombre, da false.

Por eso una data class es una buena base para un value object: un objeto que importa por lo que vale y no por cuál es.

== pregunta si se parecen; === pregunta si son el mismo.

== y los nulos

== es seguro con null: Kotlin traduce a == b a a?.equals(b) ?: (b === null). No hace falta comprobar antes si a es nulo.

val nulo: PersonaData? = null
println(nulo == d1)   // false, sin NullPointerException
println(nulo == null) // true

Comprueba tu equals() con un test

Si escribes equals() a mano, es fácil equivocarse en algo que no ves al leerlo, como olvidar hashCode(). La documentación de Kotlin fija las reglas que debe cumplir (el «contrato»): un objeto es igual a sí mismo, la igualdad funciona en los dos sentidos y, según la referencia de Any.hashCode(), si dos objetos son iguales según equals(), hashCode() tiene que devolver el mismo número en los dos.

Esas reglas caben en una función de prueba que sirve para cualquier clase. Le pasas dos objetos distintos con el mismo contenido y un tercero con otro contenido:

import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertNotEquals
import kotlin.test.assertTrue

class PersonaConEquals(val name: String) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is PersonaConEquals) return false
        return name == other.name
    }

    override fun hashCode(): Int = name.hashCode()
}

// a y b tienen el mismo contenido; distinto, otro contenido
fun <T : Any> comprobarContrato(a: T, b: T, distinto: T) {
    assertFalse(a === b, "a y b deben ser objetos distintos")
    assertEquals(a, a, "reflexiva: a == a")
    assertTrue(a == b && b == a, "simétrica: a == b y b == a")
    assertEquals(a.hashCode(), b.hashCode(), "si a == b, mismo hashCode")
    assertNotEquals(a, distinto, "otro contenido no es igual")
    assertFalse(a.equals(null), "nada es igual a null")
    assertEquals(1, setOf(a, b).size, "un set guarda uno solo")
}

fun main() {
    comprobarContrato(PersonaConEquals("Ana"), PersonaConEquals("Ana"), PersonaConEquals("Pepe"))
    println("Contrato de equals cumplido")
}

Se compila con kotlin-test, la biblioteca de aserciones que viene en el zip de kotlinc. Las órdenes suponen kotlinc en el PATH y el zip oficial del compilador descomprimido en ./kotlinc, que es de donde sale kotlin-test.jar:

kotlinc ContratoEquals.kt -cp kotlinc/lib/kotlin-test.jar -include-runtime -d contrato.jar
java -cp contrato.jar:kotlinc/lib/kotlin-test.jar ContratoEqualsKt
Contrato de equals cumplido

Borra la línea de hashCode() y vuelve a ejecutarlo. El test señala justo la regla que se rompe (los dos números dependen de la JVM; en tu equipo serán otros):

Exception in thread "main" java.lang.AssertionError: si a == b, mismo hashCode. Expected <1421795058>, actual <1555009629>.

Con una data class no hace falta escribir equals() ni hashCode(), pero puedes pasarle la misma función para comprobar que compara lo que esperas. En un proyecto de Android o con Gradle, este test iría en src/test con JUnit; aquí se ejecuta con kotlinc para no depender de nada más.

Errores frecuentes

Todas las salidas de esta sección son reales, de kotlinc-jvm 2.4.21.

1. === con números «a veces funciona»

Con Int? (un número que puede ser nulo), la JVM guarda el valor dentro de un objeto. Los números pequeños se reutilizan y los grandes no, así que === cambia de resultado según el valor:

val x: Int? = 1000
val y: Int? = 1000
println(x === y) // false
val p: Int? = 100
val q: Int? = 100
println(p === q) // true
println(x == y)  // true

El compilador ya avisa, y con Int? el aviso es más duro que con Int: no dice «obsoleto» sino «prohibido».

warning: identity equality for arguments of types 'Int?' and 'Int?' is prohibited.

Que 100 dé true es un detalle de la JVM, no algo que Kotlin garantice. Con números, siempre ==.

2. equals() sin hashCode()

Es el fallo del código original. Sin hashCode(), dos personas «iguales» entran las dos en un conjunto:

class Persona(val name: String) {
    override fun equals(other: Any?) = other is Persona && name == other.name
}
println(setOf(Persona("Ana"), Persona("Ana")).size)
2

El compilador no avisa de esto. Lo detecta un test como el de arriba o, en IntelliJ IDEA y Android Studio, la inspección del IDE.

3. Una propiedad de la data class que no cuenta

La data class solo compara las propiedades del constructor. Según la documentación de Kotlin, para excluir una propiedad de equals() se declara en el cuerpo de la clase. Si no lo sabes, parece un fallo:

data class Usuario(val email: String) {
    var visitas: Int = 0
}
val u1 = Usuario("[email protected]").apply { visitas = 3 }
val u2 = Usuario("[email protected]")
println(u1 == u2)
true

Es útil cuando lo haces a propósito (un contador que no forma parte de la identidad) y una trampa cuando no.

4. Comparar arrays con ==

Los arrays de Kotlin no comparan su contenido con ==, a diferencia de las listas:

println(arrayOf(1, 2, 3) == arrayOf(1, 2, 3))             // false
println(arrayOf(1, 2, 3) contentEquals arrayOf(1, 2, 3))  // true
println(listOf(1, 2, 3) == listOf(1, 2, 3))               // true

El compilador te lo dice:

warning: '==' on arrays compares only references. Replace '==' with 'contentEquals' to compare the arrays' contents or use '===' to remove the warning.

Esto también afecta a una data class con un Array en el constructor: su equals() generado compara el array por referencia. Si puedes, usa List.

5. Comparar tipos que no tienen nada que ver

Si comparas un texto con un número, Kotlin no te deja compilar:

val texto = "1"
val numero = 1
println(texto == numero)
error: operator '==' cannot be applied to 'String' and 'Int'.

Es una ventaja, no un problema: en JavaScript esa comparación con == daría true. Convierte antes uno de los dos (texto.toInt() == numero).

6. Cambiar un objeto que está dentro de un HashSet

Si una propiedad que usa hashCode() cambia mientras el objeto está en un conjunto, el conjunto deja de encontrarlo. Es como cambiar la etiqueta de una carpeta que ya está archivada: sigue en el cajón, pero en el cajón equivocado.

data class Etiqueta(var texto: String)
val e = Etiqueta("kotlin")
val conjunto = hashSetOf(e)
e.texto = "java"
println(e in conjunto)   // false
println(conjunto.size)   // 1

El contrato de hashCode() solo exige que no cambie mientras no se modifique la información que usa equals(). Por eso conviene que las data class que guardas en conjuntos o usas como claves de un mapa tengan solo val.

7. Double y el NaN

Con números decimales hay un caso raro que la documentación de Kotlin explica: si el compilador sabe que los dos son Double, se sigue el estándar IEEE 754 y NaN («no es un número») no es igual a nada, ni a sí mismo. Si los guardas como Any, la comparación cambia:

println(Double.NaN == Double.NaN)  // false
val n: Any = Double.NaN
println(n == Double.NaN)           // true
println(-0.0 == 0.0)               // true
val m: Any = -0.0
println(m == 0.0)                  // false

No lo vas a encontrar a menudo, pero explica por qué una lista de Double puede encontrar un NaN con contains y una comparación directa no.

Cuándo no usar ===

  • Para comparar datos. Textos, números, fechas o cualquier objeto que importe por su contenido se comparan con ==. Si dudas, ==.
  • Casi nunca en código de negocio. === tiene sentido en casos concretos: el atajo if (this === other) return true al principio de un equals(), comprobar en un test que una caché devuelve el mismo objeto o saber si dos variables apuntan a la misma instancia mutable.

Y cuándo no usar una data class:

  • Si el objeto tiene identidad propia. Dos pedidos con los mismos productos y la misma fecha siguen siendo dos pedidos distintos: lo que los distingue es su número. Ahí, o comparas solo el identificador en tu propio equals(), o no sobrescribes nada.
  • Si sus propiedades van a cambiar mientras está en un conjunto o en un mapa, por el error 6.

Ejercicio de cinco minutos

  1. Copia comprobarContrato y pásale dos PersonaData("Ana", 27) y una PersonaData("Pepe", 27). Debe pasar sin escribir equals().
  2. Añade a PersonaConEquals una propiedad val edad: Int y úsala en hashCode() (31 * name.hashCode() + edad), pero no en equals(). Llama a comprobarContrato con dos personas de nombre «Ana» y edades distintas: equals() dice que son iguales y su hash no coincide, así que el test debe fallar en «si a == b, mismo hashCode». Arréglalo comparando también la edad en equals() y pásale ahora dos personas idénticas.
  3. Busca en tu proyecto === entre números o textos y cámbialo por ==.

¿Y en JavaScript?

En JavaScript también existen == y ===, pero significan otra cosa: allí === compara sin convertir tipos. Lo tienes explicado en Diferencias entre == y === en JavaScript. Para seguir con Kotlin, mira Variables y tipos en Kotlin.

Fuentes

  • Documentación oficial de Kotlin: Equality y Data classes, consultadas en noviembre de 2026 (Kotlin 2.4).
  • Referencia de Any.hashCode(): el contrato de hashCode() (mismo valor mientras no cambie lo que usa equals, y mismo valor en dos objetos iguales). La página Equality confirma además contentEquals() para arrays y la diferencia en NaN y -0.0 según el tipo estático; Data classes, que las propiedades del cuerpo quedan fuera de equals().
  • Código: los ejemplos de la primera versión, incluido el aviso de === con Int y la prueba con setOf, se compilaron y ejecutaron el 8 de noviembre de 2026 con kotlinc-jvm 2.4.21 sobre JDK 21.0.13 (imagen Docker eclipse-temurin:21). El test del contrato, su fallo sin hashCode(), el ejercicio y los siete errores frecuentes, con sus avisos y salidas, se han ejecutado el 11 de noviembre de 2026 con kotlinc-jvm 2.4.21 y kotlin-test 2.4.21 (zip oficial de GitHub) sobre OpenJDK 25.0.5 (imagen eclipse-temurin:25).