Java Bitwise operatører

I dagens lektion vil vi stifte bekendtskab med Java Bitwise Operators og overveje eksempler på, hvordan man arbejder med dem. Du er sikkert bekendt med ordet "bit". Hvis ikke, så lad os huske hvad det betyder :) En bit er den mindste informationsenhed i en computer. Dens navn kommer fra binært ciffer . En bit kan udtrykkes med et af to tal: 1 eller 0. Der er et særligt binært talsystem baseret på enere og nuller. Vi vil ikke dykke ned i en matematisk jungle her. Vi bemærker kun, at et hvilket som helst tal i Java kan konverteres til binær form. For at gøre dette skal du bruge indpakningsklasserne. For eksempel, her er, hvordan du kan gøre dette for en int :

public class Main {

   public static void main(String[] args) {

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

Konsoloutput: 101010110 1010 10110 (jeg tilføjede mellemrummet for at gøre det lettere at læse) er tallet 342 i decimalsystemet. Vi har faktisk opdelt dette tal i individuelle bits: nuller og enere. Operationer udført på bit kaldes bitvis .

• ~ - bitvis IKKE.

Denne operator er meget enkel: den passerer over hver bit af vores tal og vender biten: nuller bliver til enere, og enere bliver nuller. Hvis vi anvender det på vores tal 342, sker det her: 101010110 er 342 repræsenteret som et binært tal 010101001 er værdien af ​​udtrykket ~342 Lad os prøve at omsætte dette til praksis:

public class Main {

   public static void main(String[] args) {

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

Konsol output: 169 169 er vores resultat ( 010101001 ) i det velkendte decimalsystem :)

• & - bitvis OG

Som du kan se, ligner det den logiske AND ( && ). &&- operatoren , vil du huske, returnerer kun sand, hvis begge operander er sande. Bitvist og fungerer på samme måde: den sammenligner to tal bit for bit. Sammenligningen giver et tredje tal. Lad os f.eks. tage tallene 277 og 432: 110110000 er 277 repræsenteret som et binært tal 1000101011 er 432 repræsenteret som et binært tal. Dernæst sammenligner operatoren & den første bit af det øverste tal med den første bit af det nederste tal. Fordi dette er en AND-operator, vil resultatet kun være 1, hvis begge bits er 1. I alle andre tilfælde er resultatet 0. 100010101 && operator Først sammenligner vi de første bit af de to tal, derefter den anden bit, så den tredje, og så videre. Som du kan se, er begge tilsvarende bits i tallene i kun to tilfælde lig med 1 (den første og femte bit). Alle andre sammenligninger gav 0'ere. Så til sidst fik vi tallet 10001000. I decimalsystemet svarer det til tallet 272. Lad os tjekke:

public class Main {

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

Konsoludgang: 272

• | - bitvis ELLER.

Denne operator fungerer på samme måde: at sammenligne to tal bit for bit. Først nu, hvis mindst én af bitsene er 1, så er resultatet 1. Lad os se på de samme tal (277 og 432): 100010101 | 110110000 _______________ 110110101 - resultat af | operator Her får vi et andet resultat: de eneste bits, der forbliver nuller, er de bits, der var nuller i begge tal. Resultatet er tallet 110110101. I decimalsystemet svarer det til tallet 437 Lad os tjekke:

public class Main {

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

Konsol output: 437 Vi beregnede alt korrekt! :)

• ^ - bitvis XOR (eksklusiv ELLER)

Vi har endnu ikke stødt på denne operatør. Men der er ikke noget kompliceret ved det. Det ligner den almindelige OR-operatør. Der er én forskel: den almindelige ELLER returnerer sand, hvis mindst én operand er sand. Men det behøver ikke at være én: Hvis begge operander er sande, er resultatet sandt. Men eksklusiv ELLER returnerer kun sand, hvis præcis én af operanderne er sand. Hvis begge operander er sande, returnerer den almindelige ELLER sand ("mindst en sand"), men XOR returnerer falsk. Derfor hedder det eksklusiv OR. Når du ved, hvordan de tidligere bitvise operatorer fungerer, kan du sikkert nemt beregne 277 ^ 432. Men lad os grave i det sammen en gang til :) 100010101 ^ 110110000 _______________ 010100101 - resultat af ^operatør Det er vores resultat. De bits, der var ens i begge tal, producerer et 0 (hvilket betyder, at testen "kun en" mislykkedes). Men de bits, der dannede et 0-1 eller 1-0 par, blev et. Vores resultat er tallet 010100101. I decimalsystemet svarer det til tallet 165. Lad os se om vores beregninger er korrekte:

public class Main {

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

Konsoludgang: 165 Super! Alt er som vi troede :) Nu er det tid til at stifte bekendtskab med bitskifte-operatører. Navnet taler for sig selv. Vi tager et tal og flytter dets bits til venstre eller højre :) Lad os se, hvordan det ser ud:

Skift til venstre

Et skift af bit til venstre er angivet 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 eksempel kaldes tallet x = 64 værdien. Det er dele af værdien, vi vil flytte. Vi flytter bitsene til venstre (du kunne have gættet dette ved retningen af ​​<<- operatoren) I det binære system kaldes tallet 64 = 1000000 Tallet y = 3 for skiftafstand. Skiftafstanden angiver, hvor mange bits til højre/venstre du vil flytte bits af tallet x I vores eksempel flytter vi dem 3 bit til venstre. For at se skiftprocessen mere tydeligt, se på billedet. I dette eksempel bruger vi int s. Ints optager 32 bits i computerens hukommelse. Sådan ser vores originale nummer 64 ud: Og nu tager vi hver af vores bits og flytter dem bogstaveligt talt til venstre med 3 steder: Tag et kig på, hvad vi har. Som du kan se, er alle vores bits flyttet, og yderligere 3 nuller er blevet tilføjet fra kanten af ​​området. Tre, fordi vi forskudte med 3. Hvis vi havde forskudt med 10, ville der være tilføjet 10 nuller. Således betyder udtrykket x << y "skift bits af tallet x til venstre med y pladser". Resultatet af vores udtryk er tallet 1000000000, hvilket er 512 i decimalsystemet. Lad os tjekke:

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);
   }
}

Konsoludgang: 512 Spot on! Teoretisk set kunne bitsene forskydes uendeligt, men fordi vores tal er en int , har vi kun 32 binære cifre til rådighed. Af disse er 7 allerede besat af 64 (1000000). Derfor, hvis vi flyttede 27 steder til venstre, ville vores eneste ene bevæge sig ud over datatypens rækkevidde og gå tabt. Kun nuller ville være tilbage!

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);
   }
}

Konsoludgang: 0 Som forventet flyttede den sig ud over de 32 tilgængelige bits og forsvandt. Vi sluttede med et 32-bit tal kun bestående af nuller. Dette svarer naturligvis til 0 i decimalsystemet. Her er en simpel regel for at huske skift til venstre: For hvert skift til venstre ganges tallet med 2. Lad os prøve at beregne følgende udtryk uden billeder af bits 111111111 << 3 Vi skal gange tallet 111111111 med 2 . Som et resultat får vi 888888888. Lad os skrive noget kode og tjekke:

public class Main {

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

Konsoludgang: 888888888

Skift til højre

Denne operation er angivet med >> . Det gør det samme, men i den anden retning! :) Vi vil ikke genopfinde hjulet. Lad os 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 af et skift til højre med 2, rykker de to ekstreme nuller i vores tal uden for rækkevidde og går tabt. Vi får 10.000, hvilket svarer til tallet 16 i decimalsystemet Konsoludgang: 16 Her er en simpel regel for at huske skift til højre: Hvert skift til højre divideres med to, og kasserer eventuelle rester. For eksempel betyder 35 >> 2, at vi skal dividere 35 med 2 to gange, og kassere resten 35/2 = 17 (kassere resten 1) 17/2 = 8 (kassere resten 1) Til sidst skulle 35 >> 2 være lig med 8. Lad os tjekke:

public class Main {

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

Konsoludgang: 8

Operatørprioritet i Java

Mens du skriver og læser kode, vil du ofte finde udtryk, der kombinerer flere operationer. Det er meget vigtigt at forstå den rækkefølge, de vil blive udført i (ellers kan du blive overrasket over resultatet) Fordi Java har masser af operationer, er hver af dem blevet tildelt en plads i en speciel tabel:

Operatør forrang

Alle operationer udføres fra venstre mod højre under hensyntagen til deres forrang. For eksempel hvis vi skriver

int x  = 6 - 4/2;

derefter udføres divisionsoperationen ( 4/2 ) først. Selvom det kommer i anden række, har det højere forrang. Parenteser og parenteser angiver maksimal forrang. Det husker du sikkert fra skolen. For eksempel hvis du tilføjer dem til udtrykket

int x  = (6 - 4)/2;

så udføres subtraktionen først, da den er indeholdt i parentes. Forrangen af ​​den logiske &&- operator er ret lav (se tabellen), så den vil normalt være sidst. For eksempel:

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

Dette udtryk vil blive udfø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;

Dernæst udføres sammenligningsoperatorerne:

• 4 > 3 = sandt

boolean x = true && 144 <= 119;

• 144 <= 119 = falsk

boolean x = true && false;

Og endelig vil AND-operatoren ( && ) blive udført sidst.

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

For eksempel har operatoren addition( + ) en højere prioritet end sammenligningsoperatoren != (ikke lig); Derfor i udtrykket

boolean x = 7 != 6+1;

6+1-operationen udføres først, derefter 7 != 7-kontrollen (som evalueres til falsk), og til sidst tildelingen af ​​resultatet (falsk) til variablen x (tildeling har generelt den laveste prioritet af alle operatorer ; se bordet). Pyha! Det var en stor lektion, men du gjorde det! Hvis du ikke helt forstod nogle af denne eller tidligere lektioner, så fortvivl ikke. Vi vil komme ind på disse emner mere end én gang i fremtiden. Et par CodeGym-lektioner om logiske og numeriske operationer. Vi kommer ikke til disse snart, men det skader ikke, at du læser dem nu.