Opérations bitwise et déplacement bitwise Kotlin

Kotlin fournit plusieurs fonctions (au format infix) pour exécuter des opérations bitwise et de déplacement. Dans cet article, vous apprendrez à effectuer des opérations bit level en Kotlin à l'aide d'exemples.

les opérateurs bitwise et les opérateurs de déplacement bitwise sont utilisés uniquement sur les types d'entiers Int et Long pour effectuer des opérations bit level.

Pour exécuter ces opérations, Kotlin fournit7fonction utilisant le symbole infix.

opérateur bitwise OU (OR)

la fonction bitwise OU compare les bits correspondants des deux valeurs. Si l'un des deux bits est1alors1. Sinon, la valeur est 0. Par exemple,

12　= 00001100 (binaire)
25　= 00011001　(binaire)
12et25opérations bitwise OU sur
　　　00001100 ou
　　　00011001
　　　________
　　　00011101　　val number　29　(décimal)

Exemple : opérations bitwise OU

Exemple
　　　　fun main(args: Array<String>) {1　val number　12
　　　　fun main(args: Array<String>) {2　val number　25
　　　　val result: Int
　　　　result = number1　or number2　　　//　result = number1.or(number2)
　　　　println(result)
}

Lors de l'exécution du programme, la sortie est :

29

opérateur bitwise ET (AND)

et la fonction bitwise compare les bits correspondants des deux valeurs. Si les deux bits sont1la valeur est1Si l'un des deux bits est à 0, la valeur est 0. Par exemple,

12　= 00001100 (binaire)
25　= 00011001　(binaire)
12et25的按位与运算
　　　00001100　and
　　　00011001
　　　________
　　　00001000　　=　8　(décimal)

示例：按位与运算

Exemple
　　　　fun main(args: Array<String>) {1　val number　12
　　　　fun main(args: Array<String>) {2　val number　25
　　　　val result: Int
　　　　result = number1　and　number2　　　//　result = number1.and(number2)
　　　　println(result)
}

Lors de l'exécution du programme, la sortie est :

8

按位异或(xor)

xor函数比较两个值的相应位。如果相应的位不同，则为1. Si les bits correspondants sont les mêmes, cela donne 0. Par exemple,

12　= 00001100 (binaire)
25　= 00011001　(binaire)
12et25l'opération de xor bit à bit
　　　00001100 xor
　　　00011001
　　　________
　　　00010101　　val number　21　(décimal)

Exemple : opération de xor bit à bit

Exemple
　　　　fun main(args: Array<String>) {1　val number　12
　　　　fun main(args: Array<String>) {2　val number　25
　　　　val result: Int
　　　　result = number1　xor number2　　　//　result = number1.xor(number2)
　　　　println(result)
}

Lors de l'exécution du programme, la sortie est :

21

inverse bit à bit inv()

fonction inv() inverse bit à bit. Elle fait passer chaque 0 à 1et chaque 1 à 0.

35　= 00100011　(binaire)
35l'opération de complément bit à bit
　　00100011　
　　________
　　11011100    =　220 (décimal)

Exemple : complément bit à bit

Exemple
　　　　val number =　35
　　　　val result: Int
　　　　result = number.inv()
　　　　println(result)
}

Lors de l'exécution du programme, la sortie est :

-36

Pourquoi devons-nous afficher　-36　au lieu de　220？

C'est parce que le compilateur affiche le nombre en2complément bit à bit. Le signe négatif des nombres binaires.

Pour tout entier n, le complément de n est2complément sera-n + 1)

　Décimal        Binaire　　　　　　　　　　　　　　　　　　　　　　2's complement
---------　　　　　　　---------　　　　　　　　　　---------------------------------------　　
0        00000000　　　　　　　　　　-(11111111+1) =　-00000000 =　-0 (décimal)
1　　　　　　　　　　　　　00000001　　　　　　　　　　-(11111110+1) =　-11111111　val number　-256(décimal)
12　　　　　　　　　　　　00001100　　　　　　　　　　-(11110011+1) =　-11110100 =　-244(décimal)
220　　　　　　　　　　　11011100　　　　　　　　　　-(00100011+1) =　-00100100 =　-36(décimal)
Remarque : le dépassement est ignoré lors du calcul　2's complement.

35le complément bit à bit de220 (décimal)22complément de 02Le complément à deux est-36par conséquent, la sortie est-36plutôt que220.

l'opérateur de déplacement à gauche (shl)

La fonction shl déplace le modèle de bits à gauche d'un certain nombre de positions, et les zéros sont déplacés vers la position de bas.

212　(binaire:　11010100)
212　shl　1　évalue à　424　(binaire:　110101000)
212　shl 0 évalue à　212　(binaire:　11010100)
212　shl　4　évalue à　3392　(binaire:　110101000000)

Exemple : déplacement bit à bit à gauche

Exemple
　　　　val number =　212
　　　　println(number shl　1)
　　　　println(number shl 0)
　　　　println(number shl　4)
}

Lors de l'exécution du programme, la sortie est :

424
212
3392

l'opérateur de déplacement à droite (shr)

La fonction shr déplace le modèle de bits à droite d'un certain nombre de positions.

212　(binaire:　11010100)
212　Déplacement à droite signé　1　calculé à　106　(binaire: 01101010)
212　shr 0 calculé à　212　(binaire:　11010100)
212　Déplacement à droite signé　8　calculé à 0 (binaire: 00000000)

si le nombre est2si le complément est utilisé, le bit de signe est déplacé vers la position de高位.

Exemple
　　　　val number =　212
　　　　println(number　shr　1)
　　　　println(number shr 0)
　　　　println(number　shr　8)
}

println(number shr

106
212
0

Lorsque vous exécutez ce programme, la sortie sera :

Opérateur de déplacement à droite non signé (ushr)

La fonction ushr déplace zéro à la position la plus à gauche.

Exemple
　　　　fun main(args: Array<String>) {1　val number　5
　　　　fun main(args: Array<String>) {2　val number　-5
　　　　//=
　　　　println(number1　Déplacement à droite signé　1)
　　　　//Déplacement à droite non signé
　　　　println(number1　ushr　1)
　　　　//=
　　　　println(number2　Déplacement à droite signé　1)
　　　　//Déplacement à droite non signé
　　　　println(number2　ushr　1)
}

Lors de l'exécution du programme, la sortie est :

2
2
-3
2147483645

Attention, pour2Le complément à deux, les fonctions de déplacement à droite signé et non signé fonctionnent de différentes manières.

2147483645de2Le complément à deux est3。