Operações de bits e de deslocamento no Kotlin

O Kotlin oferece várias funções (em forma infixa) para executar operações de bits e de deslocamento. Neste artigo, você aprenderá a executar operações de nível de bits no Kotlin com exemplos.

operadores de operação de bits e de deslocamento de bits apenas em dois tipos de inteiros (Int e Long) para executar operações de nível de bits.

Para executar essas operações, o Kotlin oferece7um número de função com sinal de infixo.

operador lógico de OR (OR)

a função or compara os bits correspondentes dos dois valores. Se qualquer um dos bits for1então será1Caso contrário, será 0. Por exemplo,

12　= 00001100 (binário)
25　= 00011001　(binário)
12e25operação lógica de OR de bits
　　　00001100 or
　　　00011001
　　　________
　　　00011101　　val number　29　(decimal)

Exemplo: operação lógica de OR de bits

Exemplo
　　　　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)
}

Executar o programa, a saída será:

29

operador lógico de AND (AND)

e a função de comparação de bits compara os bits correspondentes dos dois valores. Se ambos os bits forem1então o valor será1Se qualquer um dos dois bits for 0, o valor será 0. Por exemplo,

12　= 00001100 (binário)
25　= 00011001　(binário)
12e25a operação AND bit a bit
　　　00001100 and
　　　00011001
　　　________
　　　00001000    =　8　(decimal)

Exemplo: operação AND bit a bit

Exemplo
　　　　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)
}

Executar o programa, a saída será:

8

operação XOR bit a bit (xor)

a função xor compara os bits correspondentes de dois valores. Se os bits correspondentes forem diferentes, será1. Se os bits correspondentes forem iguais, será 0. Por exemplo,

12　= 00001100 (binário)
25　= 00011001　(binário)
12e25a operação XOR bit a bit
　　　00001100 xor
　　　00011001
　　　________
　　　00010101　　val number　21　(decimal)

Exemplo: operação de XOR bit a bit

Exemplo
　　　　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)
}

Executar o programa, a saída será:

21

negação bit a bit inv()

a função inv() faz uma negação bit a bit. Ela muda cada 0 para 1e para cada 1 para 0.

35　= 00100011　(binário)
35a operação de complemento bit a bit
　　00100011　
　　________
　　11011100    =　220 (decimal)

Exemplo: complemento bit a bit

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

Executar o programa, a saída será:

-36

Por que estamos mostrando　-36　em vez de　220？

porque o compilador exibe o número2o complemento bit a bit. O sinal negativo do número binário.

Para qualquer inteiro n, o complemento de n é2o complemento será-（n + 1)

　Decimal                                                                  Binário　　　　　　　　　　　　　　　　　　　　　　2's complemento
---------　　　　　　　---------　　　　　　　　　　---------------------------------------　　
0                                                                           00000000　　　　　　　　　　-(11111111+1) =　-00000000 =　-0(decimal)
1　　　　　　　　　　　　　00000001　　　　　　　　　　-(11111110+1) =　-11111111　val number　-256(decimal)
12　　　　　　　　　　　　00001100　　　　　　　　　　-(11110011+1) =　-11110100 =　-244(decimal)
220　　　　　　　　　　　11011100　　　　　　　　　　-(00100011+1) =　-00100100 =　-36(decimal)
Nota: o overflow é ignorado ao calcular　2's complemento.

35o complemento bit a bit de220 (decimal).22do número 02O complemento a dois é-36Portanto, a saída é-36em vez de220.

operador de deslocamento à esquerda (shl)

a função shl move o padrão de bits para a esquerda por uma quantidade específica de bits, movendo os zeros para a posição baixa.

212　(binário:　11010100)
212　shl　1　avalia como　424　(binário:　110101000)
212　shl 0 avalia como　212　(binário:　11010100)
212　shl　4　avalia como　3392　(binário:　110101000000)

Exemplo: deslocamento à esquerda de bits

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

Executar o programa, a saída será:

424
212
3392

operador de deslocamento à direita (shr)

a função shr move o padrão de bits para a direita por uma quantidade de bits especificada.

212　(binário:　11010100)
212　Deslocamento à direita assinado　1　calculado como　106　(binário: 01101010)
212　shr 0 calculado como　212　(binário:　11010100)
212　Deslocamento à direita assinado　8　calculado como 0 (binário: 00000000)

se o número for2seu complemento, então move o sinal para a posição alta.

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

println(number shr

106
212
0

Quando você executar o programa, a saída será:

Operador de deslocamento à direita sem sinal (ushr)

A função ushr move zeros para a posição mais à esquerda.

Exemplo
　　　　fun main(args: Array<String>) {1　val number　5
　　　　fun main(args: Array<String>) {2　val number　-5
　　　　//=
　　　　println(number1　Deslocamento à direita assinado　1)
　　　　//Deslocamento à direita sem sinal
　　　　println(number1　ushr　1)
　　　　//=
　　　　println(number2　Deslocamento à direita assinado　1)
　　　　//Deslocamento à direita sem sinal
　　　　println(number2　ushr　1)
}

Executar o programa, a saída será:

2
2
-3
2147483645

Atenção, para2O complemento a dois, a função de deslocamento à direita assinado e a função de deslocamento à direita sem sinal funcionam de maneira diferente.

2147483645do2O complemento a dois é3。