Bitwise Operations in Kotlin Hindi

Unlike Java, there are no bitwise and bitshift operators in Kotlin. To perform these task, various functions (supporting infix notation) are used:

  • shl – Signed shift left
  • shr – Signed shift right
  • ushr – Unsigned shift right
  • and – Bitwise and
  • or – Bitwise or
  • xor – Bitwise xor
  • inv – Bitwise inversion

1. or

The or function compares corresponding bits of two values. If either of the bits is 1, it gives 1. If not, it gives 0. For example,

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

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

Example: Bitwise or Operation

fun main(args: Array<String>) {

    val number1 = 12
    val number2 = 25
    val result: Int

    result = number1 or number2   // result = number1.or(number2)
    println(result)
}

When you run the program, the output will be:

29

2. and

The and function compares corresponding bits of two values. If both bits are 1, it is evaluated to 1. If either of the bits is 0, it is evaluated to 0. For example,

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

Bit Operation of 12 and 25
   00001100 and
   00011001
   ________
   00001000  = 8 (In 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)
}

When you run the program, the output will be:

8

3. xor

The xor function compares corresponding bits of two values. If corresponding bits are different, it gives 1. If corresponding bits are same, it gives 0. For example,

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

Bitwise OR Operation of 12 and 25
   00001100 xor
   00011001
   ________
   00010101  = 21 (In 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)
}

When you run the program, the output will be:

21

4. inv()

The inv() function inverts the bit pattern. It makes every 0 to 1, and every 1 to 0.

35 = 00100011 (In Binary)

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

Example: Bitwise complement

fun main(args: Array<String>) {

    val number = 35
    val result: Int

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

When you run the program, the output will be:

-36

Why are we getting output -36 instead of 220?

It’s because the compiler is showing 2’s complement of that number; negative notation of the binary number.

For any integer n, 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(decimal)
12            00001100          -(11110011+1) = -11110100 = -244(decimal)
220           11011100          -(00100011+1) = -00100100 = -36(decimal)

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

The bitwise complement of 35 is 220 (in decimal). The 2’s complement of 220 is -36. Hence, the output is -36 instead of 220.


5. shl

The shl function shifts bit pattern to the left by certain number of specified bits, and zero bits are shifted into the low-order positions.

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)

Example: Bitwise left shift

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

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

When you run the program, the output will be:

424
212
3392

6. shr

The shr function shifts bit pattery to the right by certin number of specified bits.

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)

If the number is a 2’s complement signed number, the sign bit is shifted into the high-order positions.

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

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

When you run the program, the ouput will be:

106
212
0

7. ushr

The ushr function shifts zero into the leftmost position.


Example: signed and unsigned Right Shift

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

When you run the program, the output will be:

2
2
-3
2147483645

Notice, how signed and unsigned right shift function works differently for 2’s complement.

The 2’s complement of 2147483645 is 3.