I denne opplæringen vil vi lære om bitvis operatør og forskjellige typer skiftoperatører i Java ved hjelp av eksempler.
I Java utfører bitvise operatører operasjoner på heltallsdata på det enkelte bitnivå. Her er det snakk heltall data byte, short, intog longtyper data.
Det er 7 operatører for å utføre bitnivåoperasjoner i Java.
| Operatør | Beskrivelse |
|---|---|
| | Bitvis ELLER |
& | Bitvis OG |
^ | Bitvis XOR |
~ | Bitvis komplement |
<< | Venstre shift |
>> | Signert Right Shift |
>>> | Usignert høyre skift |
1. Java bitvis ELLER operatør
Den bitvise ELLER- |operatoren returnerer 1 hvis minst en av operandene er 1. Ellers returnerer den 0.
Følgende sannhetstabell viser hvordan den bitvise OR-operatøren fungerer. La a og b være to operander som bare kan ta binære verdier, dvs. 1 eller 0.
| en | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Ovenstående tabell er kjent som "Sannhetstabellen" for den bitvise ELLER-operatøren.
La oss se på bitvis ELLER operasjon av to heltall 12 og 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
Eksempel 1: Bitvis ELLER
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. Java bitvis OG operatør
Bitvis AND- &operator returnerer 1 hvis og bare hvis begge operandene er 1. Ellers returnerer den 0.
Tabellen nedenfor viser hvordan bitvis AND-operatør fungerer. La a og b være to operander som bare kan ta binære verdier, dvs. 1 og 0.
| en | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
La oss ta en titt på bitvis OG-operasjon av to heltall 12 og 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
Eksempel 2: Bitvis OG
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. Java Bitwise XOR-operatør
Den bitvise XOR- ^operatøren returnerer 1 hvis og bare hvis en av operandene er 1. Hvis begge operandene er 0 eller hvis begge er 1, er resultatet 0.
Følgende sannhetstabell viser hvordan den bitvise XOR-operatøren fungerer. La a og b være to operander som bare kan ta binære verdier, dvs. 1 eller 0.
| en | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
La oss se på den bitvise XOR-operasjonen av to heltall 12 og 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
Eksempel 4: Bitvis 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. Java Bitwise komplementoperatør
Den bitvise komplementoperatøren er en unary operator (fungerer med bare en operand). Det er betegnet med ~.
Den endrer binære sifre 1 til 0 og 0 til 1 .
Java Bitwise komplementoperatør
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
Her kan vi se 2-komplementet på 36 (dvs. -36 ) er 11011100 . Denne verdien tilsvarer det bitvise komplementet på 35 .
Derfor kan vi si at det bitvise komplementet på 35 er - (35 + 1) = -36 .
Eksempel 3: Bitvis komplement
class Main ( public static void main(String() args) ( int number = 35, result; // bitwise complement of 35 result = ~number; System.out.println(result); // prints -36 ) )
Java Shift-operatører
Det er tre typer skiftoperatører i Java:
- Signert venstre skift (<<)
- Signert høyre skift (>>)
- Usignert høyre skift (>>>)
5. Java Left Shift-operatør
Venstre skiftoperatør skifter alle biter mot venstre med et bestemt antall spesifiserte biter. Det er betegnet med <<.
Java 1 bit Left Shift-operatør
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)
Her utfører vi riktig skift på 8 (dvs. at tegnet er positivt). Derfor er det ingen tegnbit. Så de venstre bitene er fylt med 0 (representerer positivt tegn).
// 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)
Her har vi brukt den signerte biten 1 til å fylle de venstre bitene.
Eksempel 6: Signert høyre skiftoperatør
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. Java usignert høyre skiftoperatør
Java gir også et usignert høyre skifte. Det er betegnet med >>>.
Her er den ledige posisjonen til venstre fylt med 0 i stedet for tegnbiten. For eksempel,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
Eksempel 7: Usignert høyre skift
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 ) )
Som vi kan se, returnerer den signerte og usignerte høyre skiftoperatøren forskjellige resultater for negative biter. For å lære mer besøk forskjellen mellom >> og >>>.
