Equality in Kotlin

Dans ce tutoriel, vous allez découvrir comment comparer deux valeurs ou deux objets ou deux références d’objet dans kotlin. Comme dans Java , dans kotlin il existe deux types d’égalité tels que

• L’ égalité structurelle (== ou équivalent à la méthode equals)
• L’égalité référentielle (=== ou vérifie si deux références pointent vers le même objet)

L’ égalité structurelle avec l’opérateur ==

L’égalité structurelle est vérifié avec l’opérateur == .Il vérifie si deux valeurs ou deux objet sont les mêmes.

Vous ne devez pas confondre l’opérateur == de kotlin avec l’opérateur == de Java car ils jouent un rôle complètement différent. En Java cet opérateur est utilisé pour vérifier si deux références pointent vers le même objet.

L’ homologue négative de l’opérateur == en kotlin est !=

.Notez que par convention, une expression comme a == b est traduite en:

a?.equals(b) ?: (b === null)

Pour mieux comprendre cette traduction lisez ce tutoriel sur la surcharge des opérateurs et lisez aussi ce tutoriel pour apprendre plus sur l’opérateur d’appel sécurisé et l’opérateur elvis

a?.equals(b) ?: (b === null) signifie que si a n’est pas nul alors il appelle equals(Any?) sinon (a est nul ) il vérifie si b est égal à nul.

Voici quelques exemples de comparaison structurelle

Comparaison structurelle de deux entiers

fun main(){
 val n1: Int = 12
 val n2: Int = 12;
 println(n1==n2)
}

Résultat: true

Comparaison structurelle de deux chaînes de caractère

val s1: String ="valeur"
 val s2: String ="valeur";
 println(s1==s2)

Résultat: true

Dans cette exemple l’opérateur == vérifie que la valeur de s1 est égal à la valeur de s2

L’égalité référentielle avec l’opérateur ===

L’égalité référentiel est vérifié avec l’opérateur ===.Il vérifie si deux références pointent vers le même objet.

Pour les valeurs représentées sous forme de types primitifs (Int,Long,Byte) à l’exécution le contrôle d’égalité === est équivalent au contrôle d’égalité ==

Comparaison référentielle de deux chaînes de caractère

fun main(){
 val s1: String ="valeur"
 val s2: String ="valeur";
 println(s1===s2)
}

Résultat: true

Comparaison référentielle de deux entiers

 val n1: Int = 12
 val n2: Int = 12;
 println(n1===n2)

Puis que en interne les types tels que Int,String sont considérés comme des types primitifs alors l’opérateur === vérifie si les valeurs des deux variables sont égales

Comparaison de vos propres objet

Pour faire une comparaison d’égalité structurelle avec des objets d’une classe que vous avez vous même créé, vous devez redéfinir dans cette classe la fonction equals.

Voici un exemple d’une classe personnalisée

data class Personne(val nom: String){

    override fun equals(other: Any?): Boolean {
        if (other == null || other !is Personne || nom != other.nom) return false;

        return true
    }

    override fun hashCode(): Int {
        var hashCode = 1
        hashCode = 31 * hashCode + (nom?.hashCode() ?: 0)
        return hashCode
    }
}

Comparaison structurelle avec des objets d’une classe qu’on a nous même créé

fun main(){
   val personne1 = Personne("Jean")
   val personne2 = Personne("Jean")
    println(personne1==personne2)
}

Résultat: true

Comparaison référentielle avec des objets d’une classe qu’on a nous même créé

fun main(){
   val personne1 = Personne("Jean")
   val personne2 = Personne("Jean")
    println(personne1===personne2)
}

Résultat: false

Conclusion

Voila nous sommes à la fin de ce tutoriel sur la comparaison d’égalité dans kotlin. J’espère que ce tutoriel vous aidera.A bientôt pour un nouveau tutoriel.

Autres ressources

https://kotlinlang.org/docs/reference/equality.html