Java Xor

De bitvise operatørene brukes vanligvis til å manipulere eller spørre det binære indekserte treet. De er ansatt for å utføre operasjonene på separate tall. Vi kan bruke dem på hvilken som helst integrert datatype inkludert int, røye, kort osv. Vi vil dekke en av de bitvise operatørene som er XOR -operatøren av Java. XOR som også kalles eksklusiv eller krever to boolske operander. Den sanne formen for XOR returneres når operandene har forskjellige verdier. XOR -operatøren er mest effektiv når ingen av de to gitte boolske forholdene er sanne samtidig.

Eksempel 1:

XOR -binære operatøren er beregnet fra venstre mot høyre når den brukes til programmet. XOR “^” -operatøren er udefinert for argumenter for strengdatatype.

offentlig klasse xorexample1
public static void main (String [] args)
boolean val1 = true;
boolean val2 = falsk;
boolsk resultat = val1 ^ val2;
System.ute.Println ("Val1 Val2:"+ Resultat);
Val1 = True;
Val2 = True;
Resultat = val1 ^ val2;
System.ute.println ("val1 ^ val2:"+ resultat);
Val1 = falsk;
Val2 = falsk;
Resultat = val1 ^ val2;
System.ute.Println ("Val1 Val2:"+ Resultat);
Val1 = True;
Val2 = falsk;
Resultat = val1 ^ val2;
System.ute.println ("val1 ^ val2: '+ resultat);

Vi lager de boolske variablene “Val1” og “Val2” som er gitt de boolske verdiene. "Resultat" -variabelen av den boolske typen er definert som er brukt hos XOR -operatøren for å evaluere XOR på både "VAL1" og "VAL2" -operandene. Println () -metoden skriver ut resultatene av XOR -operasjonen. Deretter endrer vi operandens boolske verdier og tildeler de falske verdiene for å få forskjellige resultater. Deretter gir vi de alternative boolske verdiene til disse operandene for å vise funksjonaliteten til XOR -operatøren når den ene operanden har en sann verdi og den andre har en falsk verdi.

De forskjellige tilfellene for XOR -operatøren genererer forskjellige resultater. De lignende boolske verdiene gir alltid falske verdier, og de forskjellige verdiene til operanden gir alltid sann for XOR -operatøren.

Eksempel 2:

XOR -operatøren for de boolske verdiene til operandene er demonstrert i det første eksemplet. Nå kan XOR -operatøren også brukes på den numeriske verdien for Bitwise XOR -drift.

offentlig klasse xorexample2
public static void main (String [] args)
int a = 8;
int b = 2;
System.ute.println ("a ^ b =" + (a ^ b));

Vi erklærer “A” -variabelen av INT -typen som er spesifisert med “8” heltallverdien. Den neste variabelen som er "B" blir også initialisert med "2" tallverdien. Etter det bruker vi Println () -metoden til Java for å utføre XOR-operasjonen på de tidligere spesifiserte variablene ved å kalle XOR-ligningen som blir evaluert og trykt.

Den binære verdien av “8” er “1000”. Og den binære verdien for “2” er “10”. Det oppnådde resultatet i binær form for disse operandene er “1010” som er verdien av “10” som vises i følgende terminal:

Eksempel 3:

XOR for de binære strengene kan bestemmes ved hjelp av vår metode som bruker XOR -operatøren og noen ytterligere logikk. XOR -operatøren brukes til begge strengene ved å bare sløyfe gjennom hvert tegn i begge strenger samtidig. Ta hensyn til at XOR kan operere på char -datatyper og returnerer 0 hvis karakterene er like.

offentlig klasse xorexample3
offentlig statisk streng XorbinaryString (String BS1, String BS2)
Streng x = "";
if (bs1.lengde ()> bs2.lengde())
Streng temp = "";
for (int i = 0; i bs1.lengde())
Streng temp = "";
for (int i = 0; i< bs2.length() bs1.length(); i++)
temp += "0";
bs1 = temp + bs1;

for (int i = 0; i< bs1.length(); i++)
X += bs1.Charat (i) ^ bs2.Charat (i);

returner x;

public static void main (String [] args)
System.ute.Println ("1011 ^ 1111:" + xorbinaryString ("1011 ^ 1111"));
System.ute.Println ("1 ^ 111101:" + xorbinaryString ("1 ^ 11101"));
System.ute.println ("0101 ^ 1:" + xorbinaryString ("0101 ^ 1"));
System.ute.print ("10000010 ^ 0:" + xorbinaryString ("1000001 ^ 0") + "\ n");

Vi konstruerer "XorbinaryString" -funksjonen som tar BS1- og BS2 -variablene av strengtype som et konstruktørargument. I "XorbinaryString" -funksjonen erklærer vi variabelen "X" som opprinnelig inneholder en tom streng. Etter det har vi den if-elv-hvis-betingede uttalelsen for å legge null til disse “BS1” og “BS2” strengvariablene for å gjøre lengden på de binære strengene like. Deretter har vi for-loop-distribusjonen som krysser hver karakter av "BS1" og "BS2" binære strenger og bruker disse binære strengene med XOR-operatøren for å oppnå XOR-resultatene fra dem. Main () -metoden brukes til å tilordne de binære verdiene mot de binære strengene ved å kalle "XorbinaryString" -funksjonen.

XOR -operatørresultatene oppnås for den binære strengen som inneholder de forskjellige binære verdiene som oppnås ved bruk av den tilpassede metoden.

Eksempel 4:

Den ikke -operatøren kan brukes til å utføre den samme oppgaven som XOR -operatøren i Java. Siden XOR -operatøren bare returnerer sant hvis begge forholdene er forskjellige, gjør det ikke mulig.

offentlig klasse xorexample4
public static void main (String [] args)
boolean x1 = true;
boolean x2 = falsk;
boolean x3 = true;
boolean x4 = falsk;
if ((x1 = x3))
System.ute.println ("tilstanden til xor er sann");

ellers

System.ute.println ("tilstanden til xor er falsk");

Vi erklærer noen boolske variabler som har tittelen “X1”, “X2”, “X3” og “X4”. Disse initialiseres med de boolske verdiene. Noen er spesifisert med den sanne verdien, og noen inneholder falske. Deretter har vi en if-est. Den spesifiserte tilstanden er effektiv at den bare krever en sann tilstand for å være sann. Imidlertid krever logikken flere forhold.

Utgangen fra den alternative måten for XOR -operasjonen viser følgende resultater:

Eksempel 5:

XOR -operatøren kan også brukes til å bytte heltallverdiene uten å bruke en tredje variabel. Denne tilnærmingen tilegner seg mindre minne og har en lavere tidsmessig kompleksitet.

offentlig klasse xorexample5
statisk tomrom (int m, int n)
System.ute.Println ("før du bytter.");
System.ute.println ("m =" + m);
System.ute.println ("n =" + n);

m ^= n;
n ^= m;
m ^= n;
System.ute.Println ("Etter å ha byttet.");
System.ute.println ("m =" + m);
System.ute.println ("n =" + n);

public static void main (String [] args)
Swap (21, 15);

Vi etablerer en "Swap ()" -funksjon i Java Main Class. "Swap ()" -funksjonskonstruktøren er spesifisert med parametrene "M" og "N". Etter det skriver vi ut "M" og "N" -variablene for å vise verdiene før byttedriften. Deretter bruker vi bytte -teknikken på de deklarerte "M" og "N" -variablene ved hjelp av XOR -operatøren. Skriv deretter ut de byttede verdiene for "M" og "N" -variablene. Main () -metoden kalles bytte () -funksjonen der vi initialiserer de numeriske verdiene for "M" og "N" -variablene for bytte.

Verdiene før bytting skrives ut på konsollen sammen med resultatene av etterbytteoperasjonen:

Eksempel 6:

Nå er det et komplekst scenario for XOR-operatøren for å søke etter de ikke-gjentatte verdiene fra den gitte matrisen.

offentlig klasse xorexample6
offentlig statisk int nonre -repeteatingInteger (int [] intarray)
int myxor
Intarray [0];
for (int i = 1; iMyxor = myxor ^ intarray [i];
returner Myxor;

public static void main (String [] args)
int [] MyArray = 19, 26, 45, 26, 45, 82, 19;
int nonRepeat = nonRepeatingInteger (MyArray);
System.ute.PRINT ("Ikke-repeterende heltall: + nonrepeat +" \ n ");

Vi oppretter "NonrefeatingInteger" -funksjonen som kaller konstruktøren for å erklære Int [] -arrayen "Intarray". I løpet av "ikke -repetisjonsinteger" definerer vi “Myxor” -objektet og spesifiserer “Intarray” -arrayen med lengde null som initialiseres med heltallverdiene i hovedmetoden (). Matrisen er satt med dupliserte verdier bortsett fra en verdi. For-loop brukes for å få verdiene fra matriser. Deretter er disse arrayverdiene ordnet som (19 ^ 19) ^ (26 ^ 26) ^ (45 ^ 45) ^ 82 i "Myxor" -variabelen. Som vi vet, returnerer XOR -operatøren null for lignende verdier. Så alle lignende verdier av matrisen blir null og den ikke-lignende verdien oppnås fra XOR.

Antallet som ikke gjentas i matrisen er “82” som vi hentet inne i terminalen etter XOR -teknikken.

Konklusjon

Vi dekket grunnleggende om XOR -operasjonen i denne artikkelen. Den skaffer seg færre minneintensive operatører og er enklere å implementere. Vi benyttet XOR -operatøren i det gitte programmet til Java. Vi får også en teknikk for å bestemme XOR -verdiene til binære strenger.