Toán Tử Java Bitwise Và Shift (Có Ví Dụ)

Trong hướng dẫn này, chúng ta sẽ tìm hiểu về toán tử bitwise và các loại toán tử shift khác nhau trong Java với sự trợ giúp của các ví dụ.

Trong Java, toán tử bitwise thực hiện các hoạt động trên dữ liệu số nguyên ở cấp độ bit riêng lẻ. Ở đây, dữ liệu số nguyên bao gồm byte, short, int, và longcác loại dữ liệu.

Có 7 toán tử để thực hiện các phép toán mức bit trong Java.

Nhà điều hành	Sự miêu tả
|	Bitwise HOẶC
&	Bitwise VÀ
^	Bitwise XOR
~	Bổ sung Bitwise
<<	Dịch trái
>>	Đã ký Shift phải
>>>	Shift phải không dấu

1. Toán tử HOẶC Bitwise Java

|Toán tử OR bitwise trả về 1 nếu ít nhất một trong các toán hạng là 1. Ngược lại, nó trả về 0.

Bảng sự thật sau đây thể hiện hoạt động của toán tử OR theo bit. Cho a và b là hai toán hạng chỉ có thể nhận các giá trị nhị phân tức là 1 hoặc 0.

a	b	a | b
0	0	0
0	1	1
1	0	1
1	1	1

Bảng trên được gọi là "Bảng sự thật" cho toán tử OR bitwise.

Hãy xem xét phép toán OR theo bit của hai số nguyên 12 và 25.

12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)

Ví dụ 1: Bitwise HOẶC

class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise OR between 12 and 25 result = number1 | number2; System.out.println(result); // prints 29 ) )

2. Toán tử Java Bitwise AND

&Toán tử AND bitwise trả về 1 nếu và chỉ khi cả hai toán hạng là 1. Ngược lại, nó trả về 0.

Bảng sau minh họa hoạt động của toán tử AND bitwise. Cho a và b là hai toán hạng chỉ có thể nhận các giá trị nhị phân tức là 1 và 0.

a	b	a & b
0	0	0
0	1	0
1	0	0
1	1	1

Chúng ta hãy xem thao tác bitwise AND của hai số nguyên 12 và 25.

12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)

Ví dụ 2: Bitwise AND

class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise AND between 12 and 25 result = number1 & number2; System.out.println(result); // prints 8 ) )

3. Toán tử Java Bitwise XOR

^Toán tử XOR bitwise trả về 1 nếu và chỉ khi một trong các toán hạng là 1. Tuy nhiên, nếu cả hai toán hạng đều là 0 hoặc nếu cả hai đều là 1, thì kết quả là 0.

Bảng sự thật sau đây chứng minh hoạt động của toán tử XOR bitwise. Cho a và b là hai toán hạng chỉ có thể nhận các giá trị nhị phân tức là 1 hoặc 0.

a	b	a & b
0	0	0
0	1	1
1	0	1
1	1	0

Hãy xem xét phép toán XOR bitwise của hai số nguyên 12 và 25.

12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)

Ví dụ 4: Bitwise XOR

class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise XOR between 12 and 25 result = number1 number2; System.out.println(result); // prints 21 ) )

4. Toán tử bổ sung Java Bitwise

Toán tử bổ sung bitwise là một toán tử một ngôi (chỉ hoạt động với một toán hạng). Nó được ký hiệu là ~.

Nó thay đổi các chữ số nhị phân 1 thành 0 và 0 thành 1 .

Toán tử bổ sung Java Bitwise

It is important to note that the bitwise complement of any integer N is equal to - (N + 1). For example,

Consider an integer 35. As per the rule, the bitwise complement of 35 should be -(35 + 1) = -36. Now let's see if we get the correct answer or not.

35 = 00100011 (In Binary) // using bitwise complement operator ~ 00100011 __________ 11011100

In the above example, we get that the bitwise complement of 00100011 (35) is 11011100. Here, if we convert the result into decimal we get 220.

However, it is important to note that we cannot directly convert the result into decimal and get the desired output. This is because the binary result 11011100 is also equivalent to -36.

To understand this we first need to calculate the binary output of -36.

2's Complement

In binary arithmetic, we can calculate the binary negative of an integer using 2's complement.

1's complement changes 0 to 1 and 1 to 0. And, if we add 1 to the result of the 1's complement, we get the 2's complement of the original number. For example,

// compute the 2's complement of 36 36 = 00100100 (In Binary) 1's complement = 11011011 2's complement: 11011011 + 1 _________ 11011100

Ở đây, chúng ta có thể thấy phần bù của 2 là 36 (tức là -36 ) là 11011100 . Giá trị này tương đương với phần bổ sung bitwise 35 .

Do đó, chúng ta có thể nói rằng phần bù theo bit của 35 là - (35 + 1) = -36 .

Ví dụ 3: Bổ sung Bitwise

class Main ( public static void main(String() args) ( int number = 35, result; // bitwise complement of 35 result = ~number; System.out.println(result); // prints -36 ) )

Toán tử Java Shift

Có ba loại toán tử shift trong Java:

• Đã ký Shift trái (<<)
• Đã ký Shift phải (>>)
• Shift phải không dấu (>>>)

5. Toán tử Shift Left trong Java

Toán tử dịch trái dịch chuyển tất cả các bit về phía bên trái bởi một số bit nhất định. Nó được ký hiệu là <<.

Toán tử Shift trái 1 bit trong Java

As we can see from the image above, we have a 4-digit number. When we perform a 1 bit left shift operation on it, each individual bit is shifted to the left by 1 bit.

As a result, the left-most bit (most-significant) is discarded and the right-most position(least-significant) remains vacant. This vacancy is filled with 0s.

Example 5: Left Shift Operators

class Main ( public static void main(String() args) ( int number = 2; // 2 bit left shift operation int result = number << 2; System.out.println(result); // prints 8 ) )

5. Java Signed Right Shift Operator

The signed right shift operator shifts all bits towards the right by a certain number of specified bits. It is denoted by >>.

When we shift any number to the right, the least significant bits (rightmost) are discarded and the most significant position (leftmost) is filled with the sign bit. For example,

// right shift of 8 8 = 1000 (In Binary) // perform 2 bit right shift 8>> 2: 1000>> 2 = 0010 (equivalent to 2)

Ở đây, chúng ta đang thực hiện dịch chuyển sang phải của 8 (nghĩa là dấu dương). Do đó, không có dấu hiệu bit. Vì vậy, các bit ngoài cùng bên trái được điền bằng 0 (đại diện cho dấu tích cực).

// right shift of -8 8 = 1000 (In Binary) 1's complement = 0111 2's complement: 0111 + 1 _______ 1000 Signed bit = 1 // perform 2 bit right shift 8>> 2: 1000>> 2 = 1110 (equivalent to -2)

Ở đây, chúng tôi đã sử dụng bit có dấu 1 để điền vào các bit ngoài cùng bên trái.

Ví dụ 6: Toán tử Shift phải đã ký

class Main ( public static void main(String() args) ( int number1 = 8; int number2 = -8; // 2 bit signed right shift System.out.println(number1>> 2); // prints 2 System.out.println(number2>> 2); // prints -2 ) )

7. Toán tử Shift Right Unsigned trong Java

Java cũng cung cấp một dịch chuyển bên phải không dấu. Nó được ký hiệu là >>>.

Ở đây, vị trí trống ngoài cùng bên trái được điền bằng 0 thay vì bit dấu. Ví dụ,

// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010

Ví dụ 7: Dịch chuyển sang phải chưa ký

class Main ( public static void main(String() args) ( int number1 = 8; int number2 = -8; // 2 bit signed right shift System.out.println(number1>>> 2); // prints 2 System.out.println(number2>>> 2); // prints 1073741822 ) )

Như chúng ta có thể thấy toán tử dịch phải có dấu và không dấu trả về các kết quả khác nhau cho các bit âm. Để tìm hiểu thêm, hãy truy cập Sự khác biệt giữa >> và >>>.

Share on Facebook Share on Twitter