Operazioni a bit e di shift Kotlin

Kotlin fornisce diverse funzioni (in forma infix) per eseguire operazioni a bit e di shift. In questo articolo, imparerai a eseguire operazioni a livello di bit in Kotlin con esempi.

I operatori di operazione a bit e gli operatori di shift sono utilizzati solo su due tipi di interi (Int e Long) per eseguire operazioni a livello di bit.

Per eseguire queste operazioni, Kotlin fornisce 7 funzioni con simbolo infix.

Operazione OR (or)

La funzione OR confronta i bit corrispondenti di due valori. Se almeno uno dei bit è 1, il risultato è 1. Altrimenti è 0. Ad esempio:

12　=　00001100　(Binary)
25　=　00011001　(Binary)
Operazione OR bit a bit tra 12 e 25
　　　00001100 or
　　　00011001
　　　________
　　　00011101 = 29 (decimale)

Esempio: operazione di OR bit a bit

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

Quando si esegue questo programma, l'output è:

29

Bitwise AND (and)

The AND function compares the corresponding bits of two values. If both bits are 1, the result is 1. If either bit is 0, the result is 0. For example,

12　=　00001100　(Binary)
25　=　00011001　(Binary)
Bitwise AND operation between 12 and 25
　　　00001100　and
　　　00011001
　　　________
　　　00001000　　=　8　(Decimal)

Example: Bitwise AND operation

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

Quando si esegue questo programma, l'output è:

8

Bitwise XOR (xor)

The XOR function compares the corresponding bits of two values. If the corresponding bits are different, the result is 1. If the corresponding bits are the same, the result is 0. For example,

12　=　00001100　(Binary)
25　=　00011001　(Binary)
Bitwise XOR operation between 12 and 25
　　　00001100　xor
　　　00011001
　　　________
　　　00010101　　=　21　(Decimal)

Example: Bitwise XOR operation

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

Quando si esegue questo programma, l'output è:

21

Bitwise NOT　inv()

The inv() function performs a bitwise NOT. It changes each 0 to 1, and each 1 to 0.

35　=　00100011　(Binary)
Bit complement operation for 35
　　00100011　
　　________
　　11011100　　=　220　(Decimal)

Example: Bit complement

fun main(args: Array<String>) {
　　　　val　number　=　35
　　　　val　result:　Int
　　　　result　=　number.inv()
　　　　println(result)
}

Quando si esegue questo programma, l'output è:

-36

Why do we output　-36　instead of　220?

This is because the compiler displays the 2's complement of the number. The negative sign of the binary number.

For any integer n, the 2's complement of n will be -(n + 1).

　Decimal　　　　　　　　　Binary　　　　　　　　　　　　　　　　　　　　　　2's complement
---------　　　　　　　---------　　　　　　　　　　---------------------------------------　　
0　　　　　　　　　　　　　00000000　　　　　　　　　　-(11111111+1)　=　-00000000　=　-0(decimal)
1      00000001      -(11111110+1) = -11111111 = -256(decimale)
12      00001100      -(11110011+1) = -11110100 = -244(decimale)
220      11011100      -(00100011+1) = -00100100 = -36(decimale)
Nota: L'overflow viene ignorato durante il calcolo del complemento a due.

Il complemento a due di 35 è 220 (decimale). Il complemento a due di 220 è -36. Pertanto, l'output è -36 invece di 220.

Operatore di spostamento a sinistra (shl)

La funzione shl sposta il modello di bit di un numero di posizioni specificate a sinistra, e i bit zero vengono spostati alla posizione più bassa.

212 (binario: 11010100)
212 shl 1 valuta a 424 (binario: 110101000)
212 shl 0 valuta a 212 (binario: 11010100)
212 shl 4 valuta a 3392 (binario: 110101000000)

Esempio: Spostamento a sinistra bit a bit

fun main(args: Array<String>) {
　　　　val number = 212
　　　　println(number shl 1)
　　　　println(number shl 0)
　　　　println(number shl 4)
}

Quando si esegue questo programma, l'output è:

424
212
3392

Operatore di spostamento a destra (shr)

La funzione shr sposta il modello di bit di un numero di posizioni specificate a destra.

212 (binario: 11010100)
212 shr 1 calcola 106 (binario: 01101010)
212 shr 0 calcola 212 (binario: 11010100)
212 shr 8 calcola 0 (binario: 00000000)

Se il numero è il complemento a due, sposta il bit di segno alla posizione più alta.

fun main(args: Array<String>) {
　　　　val number = 212
　　　　println(number shr 1)
　　　　println(number shr 0)
　　　　println(number shr 8)
}

Quando esegui il programma, l'output sarà:

106
212
0

Operatore di spostamento a destra senza segno (ushr)

La funzione ushr sposta lo zero alla posizione più a sinistra.

Esempio: Spostamento a destra con segno e senza segno

fun main(args: Array<String>) {
　　　　val number1 = 5
　　　　val number2 = -5
　　　　// Shift a destra con segno
　　　　println(number1 shr 1)
　　　　// Shift a destra senza segno
　　　　println(number1 ushr 1)
　　　　// Shift a destra con segno
　　　　println(number2 shr 1)
　　　　// Shift a destra senza segno
　　　　println(number2 ushr 1)
}

Quando si esegue questo programma, l'output è:

2
2
-3
2147483645

Attenzione, per il complemento a due, il funzionamento delle funzioni di shift a destra con segno e senza segno è diverso.

Il complemento a due di 2147483645 è 3.