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)
Table des matières
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
Noe Joel Vigan, auteur de ce blog, est passionné par la programmation Android. Il a créé ce blog pour partager ses connaissances sur le développement d’application android. Il est Développeur Android Fullstack, ce qui lui permet de complètement mettre en place le Backend de ses applications sur Google Cloud à défaut d’utiliser FireBase.