Un opérateur est un symbole qui indique au compilateur d’effectuer des manipulations mathématiques ou logiques spécifiques. Kotlin est riche en opérateurs intégrés et fournit les types d’opérateurs suivants :
- Opérateurs arithmétiques
- Opérateurs relationnels
- Opérateurs d’affectation
- Opérateurs unaires
- Opérateurs logiques
- Opérations au niveau du bit
Examinons maintenant ces opérateurs Kotlin un par un.
Sommaire
Les opérateurs arithmétiques
Les opérateurs arithmétiques de Kotlin sont utilisés pour effectuer des opérations mathématiques de base telles que l’addition, la soustraction, la multiplication et la division, etc.
| Opérateur | Nom | Description | Exemple |
|---|---|---|---|
| + | Addition | Ajouter deux valeurs | x + y |
| – | Soustraction | Soustraire une valeur de l’autre | x – y |
| * | Multiplication | Multiplie deux valeurs | x * y |
| / | Division | Diviser une valeur par l’autre | x / y |
| % | Modulo | Retourner le reste d’une division | x % y |
Exemple
L’exemple suivant montre différents calculs à l’aide des opérateurs arithmétiques Kotlin :
fun main(args: Array<String>) {
val x : Int = 40
val y : Int = 20
println("x + y = " + (x + y))
println("x - y = " + (x - y))
println("x / y = " + (x / y))
println("x * y = " + (x * y))
println("x % y = " + (x % y))
}
Lorsque vous exécutez le programme Kotlin ci-dessus, il génère la sortie suivante :
x + y = 60 x - y = 20 x / y = 2 x * y = 800 x % y = 0
Les opérateurs relationnels
Les opérateurs relationnels (de comparaison) de Kotlin sont utilisés pour comparer deux valeurs et renvoient une valeur booléenne : vrai ou faux.
| Opérateur | Nom | Exemple |
|---|---|---|
| > | Supérieur à | x > y |
| < | Inférieur à | x < y |
| >= | Supérieur ou égal | x >= y |
| <= | Inférieur ou égale | x <= y |
| == | égale à | x == y |
| != | non égal à | x != y |
Exemple
L’exemple suivant montre différents calculs à l’aide des opérateurs relationnels Kotlin :
fun main(args: Array<String>) {
val x : Int = 40
val y : Int = 20
println("x > y = " + (x > y))
println("x < y = " + (x < y))
println("x >= y = " + (x >= y))
println("x <= y = " + (x <= y))
println("x == y = " + (x == y))
println("x != y = " + (x != y))
}
Lorsque vous exécutez le programme Kotlin ci-dessus, il génère la sortie suivante :
x > y = true x < y = false x >= y = true x <= y = false x == y = false x != y = true
Les Opérateurs d’affectation
Les opérateurs d’affectation Kotlin sont utilisés pour affecter des valeurs aux variables.
Voici un exemple où nous avons utilisé l’opérateur d’affectation = pour affecter une valeur à deux variables :
fun main(args: Array<String>) {
val x : Int = 40
val y : Int = 20
println("x = " + x)
println("y = " + y)
}
Lorsque vous exécutez le programme Kotlin ci-dessus, il génère la sortie suivante :
x = 40 y = 20
Voici un autre exemple où nous avons utilisé l’opérateur d’affectation += pour ajouter la valeur de la variable self et la réaffecter à la même variable :
fun main(args: Array<String>) {
var x : int= 40
x += 10
println("x = " + x)
}
Lorsque vous exécutez le programme Kotlin ci-dessus, il génère la sortie suivante :
x = 50
Voici une liste de tous les opérateurs d’affectation :
Formulaire étendu d’exemple d’opérateur
| Opérator | Exemple | Forme élargie |
|---|---|---|
| = | x = 10 | x = 10 |
| += | x += 10 | x = x – 10 |
| -= | x -= 10 | x = x – 10 |
| *= | x *= 10 | x = x * 10 |
| /= | x /= 10 | x = x / 10 |
| %= | x %= 10 | x = x % 10 |
Exemple
L’exemple suivant montre différents calculs à l’aide des opérateurs d’affectation Kotlin :
fun main(args: Array<String>) {
var x : int= 40
x += 5
println("x += 5 = " + x )
x = 40 ;
x -= 5
println("x -= 5 = " + x)
x = 40
x *= 5
println("x *= 5 = " + x)
x = 40
x /= 5
println("x /= 5 = " + x)
x = 43
x %= 5
println("x %= 5 = " + x)
}
Lorsque vous exécutez le programme Kotlin ci-dessus, il génère la sortie suivante :
x += 5 = 45 x -= 5 = 35 x *= 5 = 200 x /= 5 = 8 x %= 5 = 3
Les opérateurs unaires
Les opérateurs unaires ne nécessitent qu’un seul opérande ; ils effectuent diverses opérations telles que l’incrémentation/décrémentation d’une valeur d’une unité, l’annulation d’une expression ou l’inversion de la valeur d’un booléen.
Voici la liste des opérateurs unaires Kotlin :
| Opérateur | Nom | Exemple |
|---|---|---|
| + | unaire plus | +x |
| – | unaire moins | -x |
| ++ | incrémenter par 1 | ++x |
| — | décrémenter par 1 | –x |
| ! | verser une valeur booléenne | !x |
Exemple
L’exemple suivant montre différents calculs utilisant les opérateurs unaires Kotlin :
fun main(args: Array<String>) {
var x : Int= 40
var b:Boolean = true
println("+x = " + (+x))
println("-x = " + (-x))
println("++x = " + (++x))
println("--x = " + (--x))
println("!b = " + (!b))
}
Lorsque vous exécutez le programme Kotlin ci-dessus, il génère la sortie suivante :
+x = 40 -x = -40 ++x = 41 --x = 40 !b = false
Ici, les opérateurs d’incrémentation (++) et de décrémentation (–) peuvent être utilisés comme préfixe comme ++x ou –x ainsi que comme suffixe comme x++ ou x–. La seule différence entre les deux formes est que si nous les utilisons comme préfixe, l’opérateur s’appliquera avant l’exécution de l’expression, mais s’il les utilise comme suffixe, l’opérateur s’appliquera après l’exécution de l’expression.
Les opérateurs logiques
Les opérateurs logiques Kotlin sont utilisés pour déterminer la logique entre deux variables ou valeurs :
Voici la liste des opérateurs logiques Kotlin :
| Opérateur | Nom | Description | Exemple |
|---|---|---|---|
| && | et logique | Renvoie vrai si les deux opérandes sont vrais | x && y |
| || | ou logique | Renvoie vrai si l’un des opérandes est vrai | x || y |
| ! | non logique | Inverse le résultat, renvoie faux si l’opérande est vrai | !x |
Exemple
L’exemple suivant montre différents calculs à l’aide des opérateurs logiques Kotlin :
fun main(args: Array<String>) {
var x : Boolean = true
var y: Boolean = false
println("x && y = " + (x && y))
println("x || y = " + (x || y))
println("!y = " + (!y))
}
Lorsque vous exécutez le programme Kotlin ci-dessus, il génère la sortie suivante :
x && y = false x || y = true !y = true
Les opérations binaires
Kotlin n’a pas d’opérateurs au niveau du bit mais Kotlin fournit une liste de fonctions d’assistance pour effectuer des opérations au niveau du bit.
Voici la liste des fonctions binaires de Kotlin :
| Fonction | Description | Exemple |
|---|---|---|
| shl (bits) | décalage signé vers la gauche | x.shl(y) |
| shr (bits) | décalage signé vers la droite | x.shr(y) |
| ushr (bits) | décalage non signé vers la droite | x.ushr(y) |
| and (bits) | et binaire | x.and(y) |
| or (bits) | ou binaire | x.or(y) |
| xor (bits) | xor binaire | x.xor(y) |
| inv() | inverse binaire | x.inv() |
Exemple
L’exemple suivant montre différents calculs utilisant les fonctions au niveau du bit Kotlin :
fun main(args: Array<String>) {
var x:Int = 60 // 60 = 0011 1100
var y:Int = 13 // 13 = 0000 1101
var z:Int
z = x.shl(2) // 240 = 1111 0000
println("x.shl(2) = " + z)
z = x.shr(2) // 15 = 0000 1111
println("x.shr(2) = " + z)
z = x.and(y) // 12 = 0000 1100
println("x.and(y) = " + z)
z = x.or(y) // 61 = 0011 1101
println("x.or(y) = " + z)
z = x.xor(y) // 49 = 0011 0001
println("x.xor(y) = " + z)
z = x.inv() // -61 = 1100 0011
println("x.inv() = " + z)
}
Lorsque vous exécutez le programme Kotlin ci-dessus, il génère la sortie suivante :
x.shl(2) = 240 x.shr(2) = 15 x.and(y) = 12 x.or(y) = 61 x.xor(y) = 49 x.inv() = -61
