Igualdad referencial (===) y estructural (==) en Kotlin
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í quefalse.==llama aequals(), pero la clase no lo ha sobrescrito. Elequals()que hereda deAnycompara referencias, así que también dafalse, aunque los dos tengan el mismo nombre.
Caso 3: una clase que sobrescribe equals() (override fun equals)
===sigue dandofalse: siguen siendo dos objetos.==usa nuestroequals(), que compara el nombre, y datrue.
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 dandofalse.==datruesin escribir nada: unadata classgenera automáticamenteequals(),hashCode()ytoString()a partir de las propiedades del constructor. Cond3, que tiene otro nombre, dafalse.
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 atajoif (this === other) return trueal principio de unequals(), 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
- Copia
comprobarContratoy pásale dosPersonaData("Ana", 27)y unaPersonaData("Pepe", 27). Debe pasar sin escribirequals(). - Añade a
PersonaConEqualsuna propiedadval edad: Inty úsala enhashCode()(31 * name.hashCode() + edad), pero no enequals(). Llama acomprobarContratocon 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 enequals()y pásale ahora dos personas idénticas. - 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 usaequals, y mismo valor en dos objetos iguales). La página Equality confirma ademáscontentEquals()para arrays y la diferencia enNaNy-0.0según el tipo estático; Data classes, que las propiedades del cuerpo quedan fuera deequals(). - Código: los ejemplos de la primera versión, incluido el aviso de
===conInty la prueba consetOf, se compilaron y ejecutaron el 8 de noviembre de 2026 conkotlinc-jvm2.4.21 sobre JDK 21.0.13 (imagen Dockereclipse-temurin:21). El test del contrato, su fallo sinhashCode(), el ejercicio y los siete errores frecuentes, con sus avisos y salidas, se han ejecutado el 11 de noviembre de 2026 conkotlinc-jvm2.4.21 ykotlin-test2.4.21 (zip oficial de GitHub) sobre OpenJDK 25.0.5 (imageneclipse-temurin:25).