Kotlin : Les opérateurs

Les opérateurs sont des caractères spéciaux qui effectuent des opérations sur les opérandes (valeurs ou variables). Il existe plusieurs types d'opérateurs en Kotlin.
Opérateur arithmétique, Opérateur de relation, Opérateur d'assignation, Opérateur unaire, Opérateur binaire, Opérateur logique, in Opérator, Opérateur d'accès à l'index, range Opérator.


Opérateur arithmétique

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques de base telles que l'addition (+), la soustraction (-), la multiplication (*), la division (/), etc.

Kotlin operators 1
Exemple d'opérateur arithmétique
fun main(args : Array<String>) {
var a=10 ;
var b=5 ;
println(a+b) ;
println(a-b) ;
println(a*b) ;
println(a/b) ;
println(a%b) ;
}
Kotlin code online 4


Opérateur de relation


L'opérateur relationnel montre la relation et compare les opérandes. Voici les différents opérateurs relationnels :
Kotlin operators 2
Sortie :
fun main(args : Array<String>) {
    val a = 5
    val b = 10
    val max = if (a > b) {
        println("a est plus grand que b.")
        a
    } else{
        println("b est supérieur à a.")
        b
    }
    println("max = $max")
}

Kotlin code online 5


Opérateur d'assignation

L'opérateur d'affectation "=" est utilisé pour affecter une valeur à une autre variable. L'affectation de la valeur se fait de droite à gauche.
Kotlin operators 3
Exemple d'opérateur d'assignation
fun main(args : Array<String>) {
    var a =20;var b=5
    a+=b
    println("a+=b : "+ a)
    a-=b
    println("a-=b : "+ a)
    a*=b
    println("a*=b : "+ a)
    a/=b
    println("a/=b : "+ a)
    a%=b
    println("a%=b : "+ a)

}

Kotlin code online 6

Sortie :

Kotlin code online 7


Opérateur unaire

L'opérateur unaire est utilisé avec un seul opérande. Vous trouverez ci-dessous quelques opérateurs unaires.

Exemple d'opérateur unaire
fun main(args : Array<String>){
    var a=10
    var b=5
    var flag = true
    println("+a : "+ +a)
    println("-b : "+ -b)
    println("++a : "+ ++a)
    println("--b : "+ --b)
    println("!flag : "+ !flag)
}

Sortie :

Kotlin code online 8

 

Opérateur logique

Les opérateurs logiques sont utilisés pour vérifier les conditions entre les opérandes. La liste des opérateurs logiques est donnée ci-dessous.
Opérateur Description Exp. Traduire
&& renvoie vrai si
toutes les expressions sont vraies (a>b) && (a>c) (a>b) and(a>c)
| | renvoie vrai si l'une des
expression est vraie (a>b) || (a>c) (a>b) or(a>c)
! retourne le complément
de l'expression !a a.not()
Exemple d'opérateur logique
fun main(args : Array<String>){
    var a=10
    var b=5
    var c=15
    var flag = false
    var result : Booléen
    result = (a>b) && (a>c)
    println("(a>b) && (a>c) : "+ résultat)
    result = (a>b) || (a>c)
    println("(a>b) || (a>c) : "+ result)
    résultat = !drapeau
    println("!flag : "+ result)

}
KotlinCopy
Sortie :
(a>b) && (a>c) :false
(a>b) || (a>c) :true
!flag :true

 

Opération par binaire

En Kotlin, il n'y a pas d'opérateur bitwise spécial. L'opération binaire est effectuée à l'aide d'une fonction nommée.
Fonction Expression Description
shl (bits) a.shl(b) décalage signé vers la gauche
shr (bits) a.shr(b) décalage signé vers la droite
ushr (bits) a.ushr(b) décalage non signé vers la droite
and (bits) a.and(b) Déplacement vers le bit et
or (bits) a.or(b) bit à bit ou
xor (bits) a.xor(b) xor au niveau du bit
inv() a.inv(b) inverse au sens du bit
Exemple d'opération bitwise
fun main(args : Array<String>){
    var a=10
    var b=2

    println("a.shl(b) : "+a.shl(b))
    println("a.shr(b) : "+a.shr(b))
    println("a.ushr(b :) "+a.ushr(b))
    println("a.and(b) : "+a.and(b))
    println("a.or(b) : "+a.or(b))
    println("a.xor(b) : "+a.xor(b))
    println("a.inv() : "+a.inv())

}

Sortie :
a.shl(b) : 40
a.shr(b) : 2
a.ushr(b :) 2
a.and(b) : 2
a.or(b) : 10
a.xor(b) : 8
a.inv() : -11


in Opérator


L'opérateur in est utilisé pour vérifier si un objet appartient à une collection.
Expression de l'opérateur Traduire en

dans a dans b b.contient(a)
!in a !in b !b.contains(a)
fun main(args : Array<String>) {
    val nombres = intArrayOf(1, 4, 42, -3)
    if (4 in nombres) {
        println("le tableau des nombres contient 4.")
    }
}

Sortie :
le tableau de nombres contient 4.
 


Opérateur d'accès à l'index


Voici quelques expressions utilisant l'opérateur d'accès à l'index avec les fonctions correspondantes en Kotlin.
Opérateur Traduire en
a[i] a.get(i)
a[i, n] a.get(i, n)
a[i1, i2, ..., in] a.get(i1, i2, ..., in)
a[i] = b a.set(i, b)
a[i, n] = b a.set(i, n, b)
a[i1, i2, ..., in] = b a.set(i1, i2, ..., in, b)
Exemple :
fun main(args : Array<String>) {
    val a = intArrayOf(1, 2, 3, 4, - 1)
    println(a[1])
    a[1]= 12
    println(a[1])
}
KotlinCopy
Sortie :
2
12


range Opérator:

Le range Kotlin est définie comme un intervalle entre la valeur de départ et la valeur d'arrivée. Les expressions d'intervalle sont créées avec l'opérateur (. .) qui est complété par in et !in. La valeur qui est égale ou supérieure à la valeur de début et inférieure ou égale à la valeur de fin se trouve à l'intérieur de la plage définie.
valaToZ = 'a'...'z'.
valoneToNine = 1..9
KotlinCopy
Exemple de gamme Kotlin
fun main(args : Array<String>) {

    pour (a dans 1..5){
        print(a )
    }
    println()
    for(x in 'a'...'f'){
            print(x )
        }
    println()
    val range = 1.0..5.0
    println(plage)
    println("3.14 in range is ${3.14 in range}")
}

sortie :
12345
abcdef
1.0..5.0
3.14 dans l'intervalle est vrai
KotlinCopy
nous apprendrons plus sur l'opérateur range dans la section avancée.

1 vote. Moyenne 5 sur 5.