Операции битов и位移 Kotlin

Kotlin предоставляет несколько функций (в виде infix) для выполнения операций битов и位移. В этой статье вы узнаете, как выполнять операции на уровне бит в Kotlin с помощью примеров.

Операторы битов и位移 используются только для двух типов целых чисел (Int и Long) для выполнения операций на уровне бит.

Для выполнения этих операций Kotlin предоставляет семь функций с инкрементальным символом.

Операция или (or)

Функция или сравнивает соответствующие биты двух значений. Если по крайней мере один бит из двух равен 1, то результат равен 1. В противном случае результат равен 0. Например:

12　=　00001100　(двоичный)
25　=　00011001　(двоичный)
Операция или по битам 12 и 25
　　　00001100 или
　　　00011001
　　　________
　　　00011101 = 29 (десятичное)

Пример: Операция или по битам

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

При выполнении этого программы, вывод будет:

29

Битовое И (and)

Функция and сравнивает соответствующие биты двух значений. Если оба бита равны 1, то результат равен 1. Если хотя бы один бит равен 0, то результат равен 0. Например:

12　=　00001100　(двоичный)
25　=　00011001　(двоичный)
Битовое И 12 и 25
　　　00001100　and
　　　00011001
　　　________
　　　00001000　　=　8　(десятичный)

Пример: битовое И

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

При выполнении этого программы, вывод будет:

8

Битовое исключающее ИЛИ (xor)

Функция xor сравнивает соответствующие биты двух значений. Если соответствующие биты различаются, то结果是 1. Если соответствующие биты одинаковы, то результат равен 0. Например:

12　=　00001100　(двоичный)
25　=　00011001　(двоичный)
Битовое исключающее ИЛИ 12 и 25
　　　00001100　xor
　　　00011001
　　　________
　　　00010101　　=　21　(десятичный)

Пример: битовое исключающее ИЛИ

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

При выполнении этого программы, вывод будет:

21

Битовое неопределение　inv()

Функция inv() выполняет битовое неопределение. Она меняет каждый 0 в 1 и каждый 1 в 0.

35　=　00100011　(двоичный)
Битовое дополнение 35
　　00100011　
　　________
　　11011100　　=　220　(десятичный)

Пример: битовое дополнение

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

При выполнении этого программы, вывод будет:

-36

Зачем мы выводим　-36　вместо　220?

Это потому, что компилятор показывает двоичное дополнение числа. Отрицательный знак двоичного числа.

Для любого целого числа n, его двоичная комплементация будет равна - (n + 1).

　Decimal　　　　　　　　　Binary　　　　　　　　　　　　　　　　　　　　　　2's complement
---------　　　　　　　---------　　　　　　　　　　---------------------------------------　　
0　　　　　　　　　　　　　00000000　　　　　　　　　　-(11111111+1)　=　-00000000　=　-0(десятичный)
1       00000001       -(11111110+1) = -11111111 = -256(десятичное)
12       00001100       -(11110011+1) = -11110100 = -244(десятичное)
220       11011100       -(00100011+1) = -00100100 = -36(десятичное)
Примечание: Переполнение игнорируется при вычислении двоичного дополнения.

Битовое дополнение числа 35 равно 220 (десятичное). Двоичное дополнение 220 равно -36. Поэтому вывод равен -36, а не 220.

Оператор левого смещения (shl)

Функция shl смещает битовый шаблон влево на указанное количество бит, и нули перемещаются в低位 позицию.

212 (в двоичном виде: 11010100)
212 shl 1 вычисляется как 424 (в двоичном виде: 110101000)
212 shl 0 вычисляется как 212 (в двоичном виде: 11010100)
212 shl 4 вычисляется как 3392 (в двоичном виде: 110101000000)

Пример: Битовое левое смещение

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

При выполнении этого программы, вывод будет:

424
212
3392

Оператор правого смещения (shr)

Функция shr смещает битовый шаблон вправо на указанное количество бит.

212 (в двоичном виде: 11010100)
212 shr 1 вычисляется как 106 (в двоичном виде: 01101010)
212 shr 0 вычисляется как 212 (в двоичном виде: 11010100)
212 shr 8 вычисляется как 0 (в двоичном виде: 00000000)

Если этот номер является двоичным дополнением, то флаг смещается в高位 позицию.

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

Когда вы запустите этот программ, вывод будет:

106
212
0

Оператор несигнатурного правого смещения (ushr)

Функция ushr смещает нули в наиболее левую позицию.

Пример: Сигнатурное и несигнатурное右ое смещение

fun main(args: Array<String>) {
　　　　val number1 = 5
　　　　val number2 = -5
　　　　// символический правый сдвиг
　　　　println(number1 shr 1)
　　　　// несимволический右ый сдвиг
　　　　println(number1 ushr 1)
　　　　// символический правый сдвиг
　　　　println(number2 shr 1)
　　　　// несимволический右ый сдвиг
　　　　println(number2 ushr 1)
}

При выполнении этого программы, вывод будет:

2
2
-3
2147483645

Обратите внимание, что функции символического и несимволического右ого сдвига работают по-разному для кода комплемента к двоичному коду.

Комплемент к двоичному коду 2 для 2147483645 равен 3.