U ovom ćemo uputstvu uz primjere naučiti o bitovnom operatoru i različitim vrstama operatora pomaka u Javi.
U Javi bitni operatori izvode operacije nad cjelobrojnim podacima na pojedinačnoj razini bita. Evo, podaci cijeli broj uključuje byte, short, inti longvrsta podataka.
Postoji 7 operatora koji izvode operacije na razini bita u Javi.
| Operater | Opis |
|---|---|
| | Bitno ILI |
& | Bitno I |
^ | Bitno XOR |
~ | Bitni dodatak |
<< | Lijevi pomak |
>> | Potpisan desni pomak |
>>> | Nepotpisani desni pomak |
1. Java bitni ILI operator
Bitovni ILI |operator vraća 1 ako je barem jedan od operanda 1. Inače, vraća 0.
Sljedeća tablica istine prikazuje rad bitnog ILI operatora. Neka su a i b dva operanda koja mogu poprimiti samo binarne vrijednosti, tj. 1 ili 0.
| a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Gornja tablica poznata je kao "tablica istine" za bitni ILI operator.
Pogledajmo bitovnu ILI operaciju dviju cijelih brojeva 12 i 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
Primjer 1: Bitno ILI
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 bitni i operator
Bitovni &operator AND vraća 1 ako i samo ako su oba operanda 1. Inače, vraća 0.
Sljedeća tablica prikazuje rad bitnog operatora AND. Neka su a i b dva operanda koja mogu poprimiti samo binarne vrijednosti, tj. 1 i 0.
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Pogledajmo bitni I rad dviju cijelih 12 i 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
Primjer 2: Bitno I
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 bitovni XOR operator
Bitovni XOR ^operator vraća 1 ako i samo ako je jedan od operanda 1. Međutim, ako su oba operanda 0 ili ako su oba 1, tada je rezultat 0.
Sljedeća tablica istine prikazuje rad bitnog XOR operatora. Neka su a i b dva operanda koja mogu poprimiti samo binarne vrijednosti, tj. 1 ili 0.
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Pogledajmo bitni XOR rad dviju cijelih brojeva 12 i 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
Primjer 4: Bitni 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. Operater Java bitnog komplementa
Operator bitnog komplementa je unarni operator (radi sa samo jednim operandom). Označava se sa ~.
Mijenja binarne znamenke 1 na 0 i 0 na 1 .
Java bitni operater komplementa
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
Ovdje možemo vidjeti dodatak dvojke 36 (tj. -36 ) je 11011100 . Ova je vrijednost ekvivalentna bitnom komplementu od 35 .
Dakle, možemo reći da je bitovni komplement 35 je - (35 + 1) = -36 .
Primjer 3: Bitni dodatak
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 operateri
U Javi postoje tri vrste operatora smjene:
- Potpisan lijevi pomak (<<)
- Potpisan desni pomak (>>)
- Nepotpisani desni pomak (>>>)
5. Java Left Shift Operator
Lijevi operator pomicanja pomiče sve bitove prema lijevoj strani za određeni broj specificiranih bitova. Označava se sa <<.
Java 1-bitni operator lijevog pomaka
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)
Ovdje izvodimo desni pomak od 8 (tj. Znak je pozitivan). Dakle, nema znakovnog bita. Dakle, krajnji lijevi bitovi ispunjeni su s 0 (predstavlja pozitivan znak).
// 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)
Ovdje smo upotrijebili potpisani bit 1 za popunjavanje krajnjih lijevih bitova.
Primjer 6: Potpisani operater desne smjene
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 nepotpisani operater desnog pomicanja
Java također pruža nepotpisani desni pomak. Označava se sa >>>.
Ovdje se upražnjeno krajnje lijevo mjesto umjesto znakovnog bita popunjava s 0 . Na primjer,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
Primjer 7: Nepotpisani desni pomak
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 ) )
Kao što vidimo, potpisani i nepotpisani operator desnog pomaka vraća različite rezultate za negativne bitove. Da biste saznali više, posjetite Razliku između >> i >>>.
