Kotlin 位运算和位移操作

位运算符和位移运算符仅用于两种整数类型 (Int 和 Long) 来执行位级操作。

为了执行这些操作，Kotlin 使用 中缀表示法 提供了 7 种函数。

1. or

or 函数比较两个值的对应位。如果其中任何一位是 1，则结果为 1。否则，结果为 0。例如，

12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bitwise OR Operation of 12 and 25
   00001100 or
   00011001
   ________
   00011101  = 29 (In decimal)

示例：按位或运算

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

2. and

and 函数比较两个值的对应位。如果两个位都是 1，则结果为 1。如果其中任何一位是 0，则结果为 0。例如，

12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bit Operation of 12 and 25
   00001100 and
   00011001
   ________
   00001000  = 8 (In decimal)

示例：按位与运算

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

3. xor

xor 函数比较两个值的对应位。如果对应位不同，则结果为 1。如果对应位相同，则结果为 0。例如，

12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bitwise OR Operation of 12 and 25
   00001100 xor
   00011001
   ________
   00010101  = 21 (In decimal)

示例：按位异或运算

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

4. inv()

inv() 函数反转位模式。它将每个 0 变为 1，每个 1 变为 0。

35 = 00100011 (In Binary)

Bitwise complement Operation of 35
  00100011 
  ________
  11011100  = 220 (In decimal)

示例：按位 补码

fun main(args: Array<String>) {

    val number = 35
    val result: Int

    result = number.inv()
    println(result)
}

运行程序后，输出将是

-36

为什么输出是 -36 而不是 220？

这是因为编译器显示的是该数字的 2's 补码；二进制数的负数表示。 

对于任何整数 n， n 的 2's 补码将是 -(n+1)。

 Decimal         Binary                      2's complement
---------       ---------          ---------------------------------------  
0             00000000          -(11111111+1) = -00000000 = -0(decimal)
1             00000001          -(11111110+1) = -11111111 = -256(decimal)
12            00001100          -(11110011+1) = -11110100 = -244(decimal)
220           11011100          -(00100011+1) = -00100100 = -36(decimal)

Note: Overflow is ignored while computing 2's complement.

35 的按位补码是 220 (十进制)。220 的 2's 补码是 -36。因此，输出是 -36 而不是 220。

5. shl

shl 函数将位模式向左移动指定的位数，并将零位移入低位位置。

212 (In binary: 11010100)

212 shl 1 evaluates to 424 (In binary: 110101000)
212 shl 0 evaluates to 212 (In binary: 11010100)
212 shl 4 evaluates to 3392 (In binary: 110101000000)

示例：按位左移

fun main(args: Array<String>) {
    val number = 212

    println(number shl 1)
    println(number shl 0)
    println(number shl 4)
}

运行程序后，输出将是

424
212
3392

6. shr

shr 函数将位模式向右移动指定的位数。

212 (In binary: 11010100)

212 shr 1 evaluates to 106 (In binary: 01101010)
212 shr 0 evaluates to 212 (In binary: 11010100)
212 shr 8 evaluates to 0 (In binary: 00000000)

如果数字是 2's 补码的有符号数，则符号位会被移入高位位置。

fun main(args: Array<String>) {
    val number = 212

    println(number shr 1)
    println(number shr 0)
    println(number shr 8)
}

运行程序时，输出将是

106
212
0

7. ushr

ushr 函数将零移入最左侧位置。

示例：有符号和无符号右移

fun main(args: Array<String>) {
    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)
}

运行程序后，输出将是

2
2
-3
2147483645

请注意，有符号和无符号右移函数对于 2's 补码的工作方式有所不同。

2147483645 的 2's 补码是 3。