Java Bitwise-operatører

I dagens leksjon vil vi bli kjent med Java Bitwise Operators og vurdere eksempler på hvordan du kan jobbe med dem. Du er sikkert kjent med ordet "bit". Hvis ikke, la oss huske hva det betyr :) En bit er den minste informasjonsenheten i en datamaskin. Navnet kommer fra binært siffer . En bit kan uttrykkes med ett av to tall: 1 eller 0. Det er et spesielt binært tallsystem basert på enere og nuller. Vi skal ikke fordype oss i en matematisk jungel her. Vi vil bare legge merke til at et hvilket som helst tall i Java kan konverteres til binær form. For å gjøre dette må du bruke innpakningsklassene. For eksempel, her er hvordan du kan gjøre dette for en int :

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(Integer.toBinaryString(x));
   }
}

Konsollutgang: 101010110 1010 10110 (jeg la til mellomrom for å gjøre det lettere å lese) er tallet 342 i desimalsystemet. Vi har faktisk delt dette tallet ned i individuelle biter: nuller og enere. Operasjoner utført på biter kalles bitvis .

• ~ - bitvis IKKE.

Denne operatoren er veldig enkel: den går over hver bit av tallet vårt, og snur biten: nuller blir enere, og enere blir nuller. Hvis vi bruker det på tallet 342, skjer dette: 101010110 er 342 representert som et binært tall 010101001 er verdien av uttrykket ~342 La oss prøve å sette dette i praksis:

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(~x);
   }
}

Konsollutgang: 169 169 er resultatet vårt ( 010101001 ) i det kjente desimalsystemet :)

• & - bitvis OG

Som du kan se, ser det ganske likt ut som den logiske OG ( && ). Du husker at &&- operatoren returnerer sann bare hvis begge operandene er sanne. Bitvis og fungerer på en lignende måte: den sammenligner to tall bit for bit. Sammenligningen gir et tredje tall. La oss for eksempel ta tallene 277 og 432: 110110000 er 277 representert som et binært tall 1000101011 er 432 representert som et binært tall. Deretter sammenligner operatoren og den første biten av det øvre tallet med den første biten av det nederste tallet. Fordi dette er en OG-operator, vil resultatet bare være 1 hvis begge bitene er 1. I alle andre tilfeller er resultatet 0. 100010101 && operator Først sammenligner vi de første bitene av de to tallene, deretter de andre bitene, så den tredje, og så videre. Som du kan se, i bare to tilfeller er begge tilsvarende biter i tallene lik 1 (den første og femte biten). Alle andre sammenligninger ga 0-er. Så til slutt fikk vi tallet 10001000. I desimalsystemet tilsvarer det tallet 272. La oss sjekke:

public class Main {

   public static void main(String[] args) {
       System.out.println(277&432);
   }
}

Konsollutgang: 272

• | - bitvis ELLER.

Denne operatoren fungerer på samme måte: å sammenligne to tall bit for bit. Bare nå hvis minst én av bitene er 1, så er resultatet 1. La oss se på de samme tallene (277 og 432): 100010101 | 110110000 _______________ 110110101 - resultat av | operator Her får vi et annet resultat: de eneste bitene som forblir null er de bitene som var null i begge tallene. Resultatet er tallet 110110101. I desimalsystemet tilsvarer det tallet 437 La oss sjekke:

public class Main {

   public static void main(String[] args) {
       System.out.println(277|432);
   }
}

Konsollutgang: 437 Vi regnet ut alt riktig! :)

• ^ - bitvis XOR (eksklusiv ELLER)

Vi har ennå ikke møtt denne operatøren. Men det er ikke noe komplisert med det. Det ligner på den vanlige OR-operatøren. Det er én forskjell: den vanlige ELLER returnerer sann hvis minst én operand er sann. Men det trenger ikke å være én: hvis begge operandene er sanne, er resultatet sant. Men eksklusive ELLER returnerer bare sant hvis nøyaktig en av operandene er sann. Hvis begge operandene er sanne, returnerer den vanlige ELLER sann ("minst en sann"), men XOR returnerer usann. Det er derfor det kalles eksklusiv OR. Når du vet hvordan de forrige bitvise operatorene fungerer, kan du sannsynligvis enkelt beregne 277 ^ 432. Men la oss grave i det sammen en gang til :) 100010101 ^ 110110000 _______________ 010100101 - resultatet av ^operatør Det er vårt resultat. De bitene som var like i begge tallene produserer en 0 (som betyr at "bare én"-testen mislyktes). Men bitene som dannet et 0-1 eller 1-0-par ble enere. Resultatet vårt er tallet 010100101. I desimalsystemet tilsvarer det tallet 165. La oss se om beregningene våre er riktige:

public class Main {

   public static void main(String[] args) {
       System.out.println(277^432);
   }
}

Konsollutgang: 165 Super! Alt er akkurat som vi trodde :) Nå er det på tide å bli kjent med bitskiftoperatører. Navnet taler for seg selv. Vi tar et tall, og flytter bitene til venstre eller høyre :) La oss se hvordan det ser ut:

Skift til venstre

Et skifte av biter til venstre er indikert med << Her er et eksempel:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(Integer.toBinaryString(x));
       System.out.println(Integer.toBinaryString(z));
   }
}

I dette eksemplet kalles tallet x = 64 verdien. Det er delene av verdien vi vil flytte. Vi vil forskyve bitene til venstre (du kunne ha gjettet dette ved retningen til <<- operatoren) I det binære systemet kalles tallet 64 = 1000000 Tallet y = 3 for skiftavstand. Skifteavstanden angir hvor mange biter til høyre/venstre du vil forskyve bitene av tallet x . I vårt eksempel flytter vi dem 3 biter til venstre. For å se skifteprosessen tydeligere, se på bildet. I dette eksemplet bruker vi int s. Ints opptar 32 biter i datamaskinens minne. Slik ser vårt originale nummer 64 ut: Og nå tar vi hver av bitene våre og flytter dem bokstavelig talt til venstre med 3 plasser: Ta en titt på hva vi har. Som du kan se, har alle bitene våre forskjøvet seg, og ytterligere 3 nuller er lagt til fra kanten av området. Tre, fordi vi forskjøv med 3. Hvis vi hadde forskjøvet med 10, ville 10 nuller blitt lagt til. Dermed betyr uttrykket x << y "skift bitene av tallet x til venstre med y-plasseringer". Resultatet av uttrykket vårt er tallet 1000000000, som er 512 i desimalsystemet. La oss sjekke:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

Konsollutgang: 512 Spot on! Teoretisk sett kan bitene forskyves i det uendelige, men fordi tallet vårt er en int , har vi bare 32 binære sifre tilgjengelig. Av disse er 7 allerede okkupert av 64 (1000000). Derfor, hvis vi flyttet 27 plasser til venstre, ville vår eneste flytte seg utenfor datatypens rekkevidde og gå tapt. Bare nuller ville gjenstå!

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 26;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

Konsoll-utgang: 0 Som forventet beveget den seg forbi de 32 tilgjengelige bitene og forsvant. Vi avsluttet med et 32-bits tall som kun består av nuller. Naturligvis tilsvarer dette 0 i desimalsystemet. Her er en enkel regel for å huske skift til venstre: For hvert skift til venstre multipliseres tallet med 2. La oss prøve å beregne følgende uttrykk uten bilder av biter 111111111 << 3 Vi må gange tallet 111111111 med 2 . Som et resultat får vi 888888888. La oss skrive litt kode og sjekke:

public class Main {

   public static void main(String[] args) {
       System.out.println(111111111 << 3);
   }
}

Konsollutgang: 888888888

Skift til høyre

Denne operasjonen er merket med >> . Det gjør det samme, men i den andre retningen! :) Vi vil ikke finne opp hjulet på nytt. La oss prøve det med samme int 64.

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 2;// Shift distance

       int z = (x >> y);
       System.out.println(z);
   }
}

Som et resultat av et skift til høyre med 2, flytter de to ekstreme nullene i tallet vårt utenfor rekkevidde og går tapt. Vi får 10000, som tilsvarer tallet 16 i desimalsystemet Konsoll-utdata: 16 Her er en enkel regel for å huske skift til høyre: Hvert skift til høyre deler på to, og forkaster resten. For eksempel betyr 35 >> 2 at vi må dele 35 med 2 to ganger, og forkaste restene 35/2 = 17 (kaste resten 1) 17/2 = 8 (kaste resten 1) Til slutt skal 35 >> 2 være lik 8. La oss sjekke:

public class Main {

   public static void main(String[] args) {
       System.out.println(35 >> 2);
   }
}

Konsollutgang: 8

Operatørprioritet i Java

Mens du skriver og leser kode, vil du ofte finne uttrykk som kombinerer flere operasjoner. Det er veldig viktig å forstå rekkefølgen de vil bli utført i (ellers kan du bli overrasket over resultatet) Fordi Java har mange operasjoner, har hver av dem blitt tildelt en plass i en spesiell tabell:

Operatør forrang

Alle operasjoner utføres fra venstre til høyre, med tanke på deres forrang. For eksempel hvis vi skriver

int x  = 6 - 4/2;

deretter vil delingsoperasjonen ( 4/2 ) utføres først. Selv om det kommer på andreplass, har det høyere prioritet. Parenteser og parenteser indikerer maksimal forrang. Du husker det sikkert fra skolen. For eksempel hvis du legger dem til uttrykket

int x  = (6 - 4)/2;

så utføres subtraksjonen først, siden den er omsluttet i parentes. Forrangen til den logiske &&- operatoren er ganske lav (se tabellen), så den vil vanligvis være sist. For eksempel:

boolean x = 6 - 4/2 > 3 && 12*12 <= 119;

Dette uttrykket vil bli utført som følger:

• 4/2 = 2

boolean x = 6 - 2 > 3 && 12*12 <= 119;

• 12*12 = 144

boolean x = 6 - 2 > 3 && 144 <= 119;

• 6-2 = 4

boolean x = 4 > 3 && 144 <= 119;

Deretter utføres sammenligningsoperatorene:

• 4 > 3 = sant

boolean x = true && 144 <= 119;

• 144 <= 119 = falsk

boolean x = true && false;

Og til slutt vil AND-operatoren ( && ) bli utført sist.

boolean x = true && false;
boolean x = false;

For eksempel har addisjonsoperatoren( + ) en høyere prioritet enn sammenligningsoperatoren != (ikke lik); Derfor, i uttrykket

boolean x = 7 != 6+1;

6+1-operasjonen utføres først, deretter 7 != 7-kontrollen (som evalueres til falsk), og til slutt tilordningen av resultatet (falsk) til variabelen x (tilordning har generelt lavest prioritet av alle operatorer ; se Bordet). Puh! Det var en stor leksjon, men du klarte det! Hvis du ikke helt forsto noen av denne eller tidligere leksjoner, ikke bekymre deg. Vi kommer til å berøre disse emnene mer enn én gang i fremtiden. Et par CodeGym-leksjoner om logiske og numeriske operasjoner. Vi kommer ikke til disse med det første, men det er ingen skade å lese dem nå.