Kotlin fournit plusieurs fonctions (sous forme d'infixe) pour effectuer des opérations de bit et de décalage de bits. Dans cet article, vous apprendrez à effectuer des opérations au niveau du bit dans Kotlin à l'aide d'exemples.
Les opérateurs de bits et de décalage de bits sont utilisés uniquement sur deux types intégraux ( Intet Long) pour effectuer des opérations au niveau des bits.
Pour effectuer ces opérations, Kotlin fournit 7 fonctions utilisant la notation infixe.
1. ou
La orfonction compare les bits correspondants de deux valeurs. Si l'un des bits est 1, il donne 1. Sinon, il donne 0. Par exemple,
12 = 00001100 (en binaire) 25 = 00011001 (en binaire) bit à bit OU Fonctionnement de 12 et 25 00001100 ou 00011001 ________ 00011101 = 29 (en décimal)
Exemple: bit à bit ou opération
fun main(args: Array) ( val number1 = 12 val number2 = 25 val result: Int result = number1 or number2 // result = number1.or(number2) println(result) )
Lorsque vous exécutez le programme, la sortie sera:
29
2. et
La andfonction compare les bits correspondants de deux valeurs. Si les deux bits sont 1, il est évalué à 1. Si l'un des bits est 0, il est évalué à 0. Par exemple,
12 = 00001100 (en binaire) 25 = 00011001 (en binaire) Bit Fonctionnement de 12 et 25 00001100 et 00011001 ________ 00001000 = 8 (en décimal)
Exemple: bit à bit et opération
fun main(args: Array) ( val number1 = 12 val number2 = 25 val result: Int result = number1 and number2 // result = number1.and(number2) println(result) )
Lorsque vous exécutez le programme, la sortie sera:
8
3. xor
La xorfonction compare les bits correspondants de deux valeurs. Si les bits correspondants sont différents, cela donne 1. Si les bits correspondants sont identiques, cela donne 0. Par exemple,
12 = 00001100 (en binaire) 25 = 00011001 (en binaire) au niveau du bit OU Fonctionnement de 12 et 25 00001100 x ou 00011001 ________ 00010101 = 21 (en décimal)
Exemple: opération xor au niveau du bit
fun main(args: Array) ( val number1 = 12 val number2 = 25 val result: Int result = number1 xor number2 // result = number1.xor(number2) println(result) )
Lorsque vous exécutez le programme, la sortie sera:
21
4. inv ()
La fonction inv () inverse le modèle de bits. Il fait tous les 0 à 1 et tous les 1 à 0.
35 = 00100011 (en binaire) Complément de bits Fonctionnement de 35 00100011 ________ 11011100 = 220 (en décimal)
Exemple: complément au niveau du bit
fun main(args: Array) ( val number = 35 val result: Int result = number.inv() println(result) )
Lorsque vous exécutez le programme, la sortie sera:
-36
Pourquoi obtenons-nous une sortie -36 au lieu de 220?
C'est parce que le compilateur montre le complément de 2 de ce nombre; notation négative du nombre binaire.
Pour tout entier n, le complément à 2 de n sera -(n+1).
Complément décimal binaire 2 --------- --------- ---------------------------- ----------- 0 00000000 - (11111111 + 1) = -00000000 = -0 (décimal) 1 00000001 - (11111110 + 1) = -11111111 = -256 (décimal) 12 00001100 - (11110011 +1) = -11110100 = -244 (décimal) 220 11011100 - (00100011 + 1) = -00100100 = -36 (décimal) Remarque: le débordement est ignoré lors du calcul du complément à 2.
Le complément bit à bit de 35 est 220 (en décimal). Le complément 2 de 220 est -36. Par conséquent, la sortie est -36 au lieu de 220.
5. shl
La shlfonction décale le motif binaire vers la gauche d'un certain nombre de bits spécifiés, et zéro bit est décalé vers les positions d'ordre inférieur.
212 (en binaire: 11010100) 212 shl 1 évalue à 424 (en binaire: 110101000) 212 shl 0 évalue à 212 (en binaire: 11010100) 212 shl 4 évalue à 3392 (en binaire: 110101000000)
Exemple: décalage gauche au niveau du bit
fun main(args: Array) ( val number = 212 println(number shl 1) println(number shl 0) println(number shl 4) )
Lorsque vous exécutez le programme, la sortie sera:
424 212 3392
6. shr
La shrfonction décale le parcours de bits vers la droite d'un certain nombre de bits spécifiés.
212 (en binaire: 11010100) 212 shr 1 évalue à 106 (en binaire: 01101010) 212 shr 0 évalue à 212 (en binaire: 11010100) 212 shr 8 évalue à 0 (en binaire: 00000000)
Si le nombre est un nombre signé de complément à 2, le bit de signe est décalé vers les positions d'ordre supérieur.
fun main(args: Array) ( val number = 212 println(number shr 1) println(number shr 0) println(number shr 8) )
Lorsque vous exécutez le programme, la sortie sera:
106 212 0
7. ushr
La ushrfonction décale zéro dans la position la plus à gauche.
Exemple: décalage vers la droite signé et non signé
fun main(args: Array) ( val number1 = 5 val number2 = -5 // Signed right shift println(number1 shr 1) // Unsigned right shift println(number1 ushr 1) // Signed right shift println(number2 shr 1) // Unsigned right shift println(number2 ushr 1) )
Lorsque vous exécutez le programme, la sortie sera:
2 2-3 2147483645
Remarquez que la fonction de décalage à droite signée et non signée fonctionne différemment pour le complément à 2.
Le complément de 2 2147483645est 3.
