Bitvis operatører i Java | Forklart
Hvordan bitvis operatører fungerer i Java
Denne delen presenterer syntaks og arbeid for hver bitvis operatør i Java.
Bitvis og (&): Denne operatøren er relatert til logisk og drift av Java. Imidlertid sammenligner bitvis og operatøren operander og returnerer 1 hvis begge tallene har 1 på samme sted. Hvis bitene på samme sted har annet enn 1,1 -kombinasjonen, vil den erstatte 0 i den resulterende biten. Syntaksen som er gitt nedenfor, hjelper til med å bruke bitvis og drift i Java.
operand1 & operand2;Bitvis eller (|): Denne operatøren sammenligner biter av operander og returnerer 1 hvis operandene har andre enn 0,0 biter på plass. Bitvis eller praktiseres ved hjelp av følgende syntaks:
operand1 | operand2;Bitvis xor (^): Dette fungerer annerledes enn bitvis eller og bitvis og. Den returnerer 1 hvis begge operandene har forskjellige biter og den returnerer 0 i tilfelle de samme operandene. Følgende syntaks må følges for å utøve bitvis XOR:
operand1 ^ operand2;Bitvis komplement (~): Bitvis komplement (~). Dette refererer til å endre bitene til et tall fra 0 til 1 og 1 til 0. Syntaksen som er gitt nedenfor, må følges for å bruke bitvis komplementoperatør:
~ operand;Merk: Java -kompilatoren tar 2s komplement for å bruke bitvis komplementoperatør.
Bitvis venstre skiftoperatør (<<): Denne operatøren forskyver litt antall til venstre med et bestemt nummer. Følgende syntaks må følges for å bruke den venstre skiftoperatøren:
operand1<Bitvis usammet høyre skift (>>>): Dette refererer også til å skifte til høyre ved å okkupere den ledige plassen med “0“. Syntaksen nedenfor kan brukes til å bruke den bitvis usignerte operatøren:
operand1 >> operand2;Mens de arbeider med skiftoperatører, anbefales det at Operand2 må være mindre enn Operand1, ellers kan en feil returneres. Dessuten kan de negative tallene ikke brukes til å anvende skiftoperatørene, da resultatet kan være uendelig.
Hvordan bruke bitvis operatører i Java
Denne delen gir implementering av flere bitvise operatører i Java.
Bruker bitvis eller (|): Java -koden skrevet nedenfor praktiseres ved hjelp av bitvis eller operatør.
pakke newpack;offentlig klasse bitvisop
public static void main (String [] args)
// initialisere variabler
int a = 4, b = 6;
// Skrive ut binæren til variabel a
System.ute.Println (heltall.TobinaryString (A));
// Skrive ut den binære av variabelen B
System.ute.Println (heltall.TobinaryString (B));
// Bruke OR -operatøren på A og B
System.ute.println ("resultatet av a | bis:" +(a | b));
// Skrive ut binæren til A | B
System.ute.Println (heltall.TobinaryString (A | B));
Beskrivelsen av koden er:
- initialisere to variabler en og b
- Skrive ut binærene til variabler, en og b
- skriver ut resultatet av a | b
- Får det binære av a | b
Merk: Å skrive ut/få det binære av heltallet i koden ovenfor er valgfritt. Vi har brukt det til bedre forståelse, ellers utfører Java automatisk bitvise operasjoner på den tilsvarende binære av nummeret.
Utgangen fra koden er gitt nedenfor:
Utgangen viser at det binære antallet “A = 4” og “B = 6” er henholdsvis "100" og "110". Og når den bitvise "eller" operatøren blir brukt, er resultatet 6 og dens ekvivalente binære er "110".
Bruker bitvis og (&): For å demonstrere bruken av Bitwise, og vi har øvd på følgende Java -kode.
pakke newpack;offentlig klasse bitvisop
public static void main (String [] args)
// initialisere variabler
int x = 5, y = 7;
// Skrive ut binæren til variabel x
System.ute.Println (heltall.TobinaryString (x));
// Skrive ut binæren i variabelen y
System.ute.Println (heltall.TobinaryString (Y));
// Bruke og operatøren på x og y
System.ute.println ("Resultatet av x & y er:" +(x & y));
// Skrive ut det binære av x & y
System.ute.Println (heltall.TobinaryString (x & y));
Den ovennevnte koden er beskrevet som:
- Initialiserer to variabler x og y
- Skrive ut det binære av x
- Skrive ut det binære av y
- Påføring Og operatør på x,y
- trykket det binære av x & y
Utgangen fra ovennevnte kode er vist nedenfor:
Fra utgangen observeres det at det binære av “x = 5” og “y = 7” er henholdsvis "101" og "111". Når bitvis OG brukes på disse, resultatet er “5” som har en binær verdi “101”.
Bruke bitvis komplement (~): Bitvis komplementoperatør brukes i koden som følger med blåste.
pakke newpack;offentlig klasse bitvisop
public static void main (String [] args)
// initialisere variabel
int z = 2;
// ved hjelp av ~ operatøren på z
System.ute.println ("Resultatet av ~ z er:" + ~ z);
Ovennevnte kode får verdien av z = 2 og skriver ut bitvis komplement av z.
Utgangen kan sees nedenfor:
Bruker bitvis venstre skift (<<): Vi har øvd på følgende Java -kode for å implementere bitvis venstre skiftoperatør.
pakke newpack;offentlig klasse bitvisop
public static void main (String [] args)
// initialisere variabel
int a = 4;
// binær av en
System.ute.Println (heltall.TobinaryString (A));
// ved hjelp av bitvis venstre skift på en
System.ute.println (a<<2);
// binær av en<<2
System.ute.Println (heltall.TobinaryString (a<<2));
Ovennevnte kode er beskrevet nedenfor:
- en Variabel initialiseres
- trykket det binære av en
- Bruker bitvis skiftoperatør på en
- Få den binære av en<<2 (Antall biter som vil bli forskjøvet)
Utgangen til koden vises nedenfor:
Fra utgangen observeres det at den binære av “A = 4” er “100”, og når 2 bits forskyves, ville binæren være “10000” og dens tilsvarende desimal ville være “16”.
Bruker bitvis høyre skift (>>): Bruken av riktig skiftoperatør er beskrevet i følgende kode.
pakke newpack;offentlig klasse bitvisop
public static void main (String [] args)
// initialisere variabel
int a = 7;
// binær av en
System.ute.Println (heltall.TobinaryString (A));
// Bruke bitvis høyre skift på en
System.ute.println (a >> 2);
// binær av a >> 2
System.ute.Println (heltall.TobinaryString (a >> 2));
Koden er beskrevet som:
- variabel en er initialisert
- binær av en er trykt
- Anvendt høyre skift på en
- trykket det binære av A >> 2.
Utgangen fra koden er gitt her:
Utgangen viser at de høyre 2 bitene fjernes fra “111” (binær på 7) og den resulterende binære er “1”.
Bruke bitvis usignert høyre skift (>>>): Følgende kode viser bruken av den bitvis usignerte høyre skiftoperatøren.
pakke newpack;offentlig klasse bitvisop
public static void main (String [] args)
// initialisere variabel
int x = 11;
// binær av x
System.ute.Println (heltall.TobinaryString (x));
// Bruke bitvis usignert høyre skift på x
System.ute.println (x >>> 2);
// binær av x >>> 2
System.ute.Println (heltall.TobinaryString (x >>> 2));
Beskrivelsen av koden er som:
- initialisert en variabel x
- trykket det binære av x
- trykket ut resultatet av x >>> 2
- oppnådd det binære av x >>> 2
Utgangen kan sees i følgende bilde:
Den usignerte høyre skiftoperatøren beveger seg biten til høyre og den ledige plassen er okkupert av 2 (da vi har satt antall biter til 2) 0 -er. Dessuten observeres det fra utgangen at de høyre 2 bitene fjernes.
Konklusjon
De bitvise operatørene i Java praktiseres ved å utføre flere operasjoner på bitvise mønstre. Bitvis mønster vurderer bitene for å manipulere dataene. Denne artikkelen demonstrerer flere bitvise operatører i Java. De bitvise operatørene inkluderer bitvis og, bitvis eller, bitvis komplement, xor osv. Du ville ha lært grunnleggende arbeid og bruk av alle disse bitvis operatørene i Java.