Operator Bitwise Java

1. Ikhtisar

Operator digunakan dalam bahasa Java untuk mengoperasikan data dan variabel.

Dalam tutorial ini, kita akan menjelajahi Operator Bitwise dan cara kerjanya di Java.

2. Operator Bitwise

Operator bitwise bekerja pada digit biner atau bit nilai input. Kita dapat menerapkan ini ke tipe integer - long, int, short, char, dan byte.

Sebelum menjelajahi operator bitwise yang berbeda, pertama-tama mari kita pahami cara kerjanya.

Operator bitwise bekerja pada biner yang setara dengan angka desimal dan melakukan operasi pada mereka sedikit demi sedikit sesuai operator yang diberikan:

  • Pertama, operan diubah menjadi representasi binernya
  • Selanjutnya, operator diterapkan ke setiap bilangan biner dan hasilnya dihitung
  • Akhirnya, hasilnya diubah kembali ke representasi desimalnya

Mari kita pahami dengan sebuah contoh; mari kita ambil dua bilangan bulat:

int value1 = 6; int value2 = 5;

Selanjutnya, mari terapkan operator OR bitwise pada angka-angka ini:

int result = 6 | 5;

Untuk melakukan operasi ini, pertama, representasi biner dari angka-angka ini akan dihitung:

Binary number of value1 = 0110 Binary number of value2 = 0101

Kemudian operasi akan diterapkan ke setiap bit. Hasilnya mengembalikan angka biner baru:

0110 0101 ----- 0111

Akhirnya, hasil 0111 akan diubah kembali menjadi desimal yang sama dengan 7 :

result : 7

Operator bitwise selanjutnya diklasifikasikan sebagai operator bitwise logical dan bitwise shift. Sekarang mari kita bahas setiap jenis.

3. Operator Logis Bitwise

Operator logika bitwise adalah AND (&), OR (|), XOR (^), dan NOT (~).

3.1. Bitwise ATAU (|)

Operator OR membandingkan setiap digit biner dari dua bilangan bulat dan memberikan kembali 1 jika salah satunya adalah 1.

Ini mirip dengan || operator logika yang digunakan dengan boolean. Ketika dua boolean dibandingkan, hasilnya benar jika salah satunya benar. Demikian pula, outputnya adalah 1 jika salah satunya adalah 1.

Kami melihat contoh operator ini di bagian sebelumnya:

@Test public void givenTwoIntegers_whenOrOperator_thenNewDecimalNumber()  value2; assertEquals(7, result); 

Mari kita lihat representasi biner dari operasi ini:

0110 0101 ----- 0111

Di sini, kita dapat melihat bahwa menggunakan OR, 0 dan 0 akan menghasilkan 0, sedangkan kombinasi apapun dengan setidaknya 1 akan menghasilkan 1.

3.2. Bitwise DAN (&)

Operator AND membandingkan setiap digit biner dari dua bilangan bulat dan mengembalikan 1 jika keduanya adalah 1, jika tidak, ia mengembalikan 0.

Ini mirip dengan operator && dengan nilai boolean . Ketika nilai-nilai dua boolean adalah benar hasil dari operasi && adalah benar.

Mari kita gunakan contoh yang sama seperti di atas, kecuali sekarang menggunakan operator & sebagai ganti | operator:

@Test public void givenTwoIntegers_whenAndOperator_thenNewDecimalNumber() { int value1 = 6; int value2 = 5; int result = value1 & value2; assertEquals(4, result); }

Mari kita juga melihat representasi biner dari operasi ini:

0110 0101 ----- 0100

0100 adalah 4 dalam desimal, oleh karena itu, hasilnya adalah:

result : 4

3.3. Bitwise XOR (^)

Operator XOR membandingkan setiap digit biner dari dua bilangan bulat dan memberikan kembali 1 jika kedua bit yang dibandingkan berbeda. Ini berarti jika bit dari kedua bilangan bulat adalah 1 atau 0 hasilnya akan menjadi 0; jika tidak, hasilnya akan menjadi 1:

@Test public void givenTwoIntegers_whenXorOperator_thenNewDecimalNumber() { int value1 = 6; int value2 = 5; int result = value1 ^ value2; assertEquals(3, result); }

Dan representasi biner:

0110 0101 ----- 0011

0011 is 3 in decimal, therefore, the result is:

result : 3

3.4. Bitwise COMPLEMENT (~)

Bitwise Not or Complement operator simply means the negation of each bit of the input value. It takes only one integer and it's equivalent to the ! operator.

This operator changes each binary digit of the integer, which means all 0 become 1 and all 1 become 0. The ! operator works similarly for boolean values: it reverses boolean values from true to false and vice versa.

Now let's understand with an example how to find the complement of a decimal number.

Let's do the complement of value1 = 6:

@Test public void givenOneInteger_whenNotOperator_thenNewDecimalNumber() { int value1 = 6; int result = ~value1; assertEquals(-7, result); }

The value in binary is:

value1 = 0000 0110

By applying the complement operator, the result will be:

0000 0110 -> 1111 1001

This is the one’s complement of the decimal number 6. And since the first (leftmost) bit is 1 in binary, it means that the sign is negative for the number that is stored.

Now, since the numbers are stored as 2’s complement, first we need to find its 2’s complement and then convert the resultant binary number into a decimal number:

1111 1001 -> 0000 0110 + 1 -> 0000 0111

Finally, 0000 0111 is 7 in decimal. Since the sign bit was 1 as mentioned above, therefore the resulting answer is:

result : -7

3.5. Bitwise Operator Table

Let's summarize the result of the operators we've seen to so far in a comparison table:

A B A|B A&B A^B ~A 0 0 0 0 0 1 1 0 1 0 1 0 0 1 1 0 1 1 1 1 1 1 0 0

4. Bitwise Shift Operators

Binary shift operators shift all the bits of the input value either to the left or right based on the shift operator.

Let's see the syntax for these operators:

value  

The left side of the expression is the integer that is shifted, and the right side of the expression denotes the number of times that it has to be shifted.

Bitwise shift operators are further classified as bitwise left and bitwise right shift operators.

4.1. Signed Left Shift [<<]

The left shift operator shifts the bits to the left by the number of times specified by the right side of the operand. After the left shift, the empty space in the right is filled with 0.

Another important point to note is that shifting a number by one is equivalent to multiplying it by 2, or, in general, left shifting a number by n positions is equivalent to multiplication by 2^n.

Let's take the value 12 as the input value.

Now, we will move it by 2 places to the left (12 <<2) and see what will be the final result.

The binary equivalent of 12 is 00001100. After shifting to the left by 2 places, the result is 00110000, which is equivalent to 48 in decimal:

@Test public void givenOnePositiveInteger_whenLeftShiftOperator_thenNewDecimalNumber() { int value = 12; int leftShift = value << 2; assertEquals(48, leftShift); } 

This works similarly for a negative value:

@Test public void givenOneNegativeInteger_whenLeftShiftOperator_thenNewDecimalNumber() { int value = -12; int leftShift = value << 2; assertEquals(-48, leftShift); }

4.2. Signed Right Shift [>>]

The right shift operator shifts all the bits to the right. The empty space in the left side is filled depending on the input number:

  • When an input number is negative, where the leftmost bit is 1, then the empty spaces will be filled with 1
  • When an input number is positive, where the leftmost bit is 0, then the empty spaces will be filled with 0

Let's continue the example using 12 as input.

Now, we will move it by 2 places to the right(12 >>2) and see what will be the final result.

The input number is positive, so after shifting to the right by 2 places, the result is 0011, which is 3 in decimal:

@Test public void givenOnePositiveInteger_whenSignedRightShiftOperator_thenNewDecimalNumber() { int value = 12; int rightShift = value >> 2; assertEquals(3, rightShift); }

Also, for a negative value:

@Test public void givenOneNegativeInteger_whenSignedRightShiftOperator_thenNewDecimalNumber() { int value = -12; int rightShift = value >> 2; assertEquals(-3, rightShift); }

4.3. Unsigned Right Shift [>>>]

This operator is very similar to the signed right shift operator. The only difference is that the empty spaces in the left are filled with 0 irrespective of whether the number is positive or negative. Therefore, the result will always be a positive integer.

Let's right shift the same value of 12:

@Test public void givenOnePositiveInteger_whenUnsignedRightShiftOperator_thenNewDecimalNumber() { int value = 12; int unsignedRightShift = value >>> 2; assertEquals(3, unsignedRightShift); }

And now, the negative value:

@Test public void givenOneNegativeInteger_whenUnsignedRightShiftOperator_thenNewDecimalNumber() { int value = -12; int unsignedRightShift = value >>> 2; assertEquals(1073741821, unsignedRightShift); }

5. Difference Between Bitwise and Logical Operators

There are a few differences between the bitwise operators we've discussed here and the more commonly known logical operators.

First, logical operators work on boolean expressions and return boolean values (either true or false), whereas bitwise operators work on binary digits of integer values (long, int, short, char, and byte) and return an integer.

Also, logical operators always evaluate the first boolean expression and, depending on its result and the operator used, may or may not evaluate the second. On the other hand, bitwise operators always evaluate both operands.

Finally, logical operators are used in making decisions based on multiple conditions, while bitwise operators work on bits and perform bit by bit operations.

6. Kasus Penggunaan

Beberapa kasus penggunaan potensial dari operator bitwise adalah:

  • Tumpukan komunikasi di mana bit individu di header yang dilampirkan ke data menandakan informasi penting
  • Dalam sistem tertanam untuk mengatur / menghapus / beralih hanya satu bit dari register tertentu tanpa mengubah bit yang tersisa
  • Untuk mengenkripsi data untuk masalah keamanan menggunakan operator XOR
  • Dalam kompresi data dengan cara mengubah data dari satu representasi ke representasi lainnya, untuk mengurangi jumlah ruang yang digunakan

7. Kesimpulan

Dalam tutorial ini, kita belajar tentang jenis operator bitwise dan perbedaannya dari operator logika. Kami juga melihat beberapa kasus penggunaan potensial untuk mereka.

Semua contoh kode dalam artikel ini tersedia di GitHub.