Java bitenkénti operátorok

A mai leckében megismerkedünk a Java Bitwise operátorokkal, és példákat tekintünk meg a velük való munkavégzésre. Valószínűleg ismeri a "bit" szót. Ha nem, akkor idézzük fel, mit jelent :) A bit az információ legkisebb egysége a számítógépben. A neve bináris számjegyből származik . Egy bit két szám egyikével fejezhető ki: 1 vagy 0. Létezik egy speciális kettes számrendszer, amely egyeseken és nullákon alapul. Itt nem fogunk belemerülni egy matematikai dzsungelbe. Csak azt jegyezzük meg, hogy a Java bármely szám bináris alakra konvertálható. Ehhez a wrapper osztályokat kell használni. Például a következőképpen teheti meg ezt egy int esetén :

public class Main {

   public static void main(String[] args) {

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

A konzol kimenete: 101010110 1010 10110 (szóközt tettem hozzá, hogy könnyebben olvasható legyen) a 342-es szám a decimális rendszerben. Valójában ezt a számot egyedi bitekre bontottuk: nullákra és egyesekre. A biteken végrehajtott műveleteket bitenkéntinek nevezzük .

• ~ - bitenként NEM.

Ez az operátor nagyon egyszerű: átadja a számunk minden bitjét, és megfordítja a bitet: a nullákból egyesek, az egyesekből nullák lesznek. Ha a 342-es számunkra alkalmazzuk, a következő történik: 101010110 a 342 bináris számként ábrázolva 010101001 a ~342 kifejezés értéke. Próbáljuk meg ezt a gyakorlatban átültetni:

public class Main {

   public static void main(String[] args) {

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

Konzol kimenet: 169 169 a mi eredményünk ( 010101001 ) az ismerős, decimális rendszerben :)

• & - bitenkénti ÉS

Amint látja, nagyon hasonlít a logikai ÉS-hez ( && ). A && operátor, emlékszel, csak akkor ad vissza igazat, ha mindkét operandus igaz. Bitenként és hasonló módon működik: két számot bitenként hasonlít össze. Az összehasonlítás egy harmadik számot eredményez. Vegyük például a 277-et és a 432-t: 110110000 277 bináris számként ábrázolva 1000101011 432 bináris számként ábrázolva. Ezután az & operátor a felső szám első bitjét összehasonlítja az alsó szám első bitjével. Mivel ez egy ÉS operátor, az eredmény csak akkor lesz 1, ha mindkét bit 1. Minden más esetben az eredmény 0. 100010101 && operátor Először összehasonlítjuk a két szám első bitjét, majd a második bitet, majd a harmadikat, és így tovább. Amint láthatja, csak két esetben mindkét megfelelő bit a számokban egyenlő 1-gyel (az első és az ötödik bit). Minden más összehasonlítás 0-t eredményezett. Így végül a 10001000 számot kaptuk. Tizedes rendszerben ez a 272-es számnak felel meg. Ellenőrizzük:

public class Main {

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

Konzol kimenet: 272

• | - bitenként VAGY.

Ez az operátor ugyanúgy működik: két szám bitenkénti összehasonlítása. Csak most, ha legalább az egyik bit 1, akkor az eredmény 1. Nézzük ugyanazokat a számokat (277 és 432): 100010101 | 110110000 _______________ 110110101 - a | operátor Itt más eredményt kapunk: csak azok a bitek maradnak nullák, amelyek mindkét számban nullák voltak. Az eredmény a 110110101 szám. Tizedes rendszerben a 437-es számnak felel meg. Ellenőrizzük:

public class Main {

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

Konzol kimenet: 437 Mindent helyesen számoltunk! :)

• ^ - bitenkénti XOR (kizárólagos VAGY)

Még nem találkoztunk ezzel az operátorral. De nincs ebben semmi bonyolult. Hasonló a hagyományos VAGY operátorhoz. Egy különbség van: a közönséges VAGY igazat ad vissza, ha legalább egy operandus igaz. De nem kell egynek lennie: ha mindkét operandus igaz, az eredmény igaz. De a kizárólagos VAGY csak akkor ad vissza igazat, ha az operandusok közül pontosan az egyik igaz. Ha mindkét operandus igaz, akkor a közönséges VAGY igaz ("legalább egy igaz"), de az XOR hamis értéket ad vissza. Ezért hívják exkluzív VAGY. Az előző bitenkénti operátorok működésének ismeretében valószínűleg könnyen kiszámolhatja a 277 ^ 432-t. De ássuk bele még egyszer :) 100010101 ^ 110110000 _______________ 010100101 - a ^ eredményeoperátor Ez a mi eredményünk. Azok a bitek, amelyek mindkét számban megegyeztek, 0-t adnak (ami azt jelenti, hogy az "egyetlen" teszt sikertelen volt). De a bitek, amelyek 0-1 vagy 1-0 párt alkottak, azok lettek. Eredményünk a 010100101 szám. Tizedes rendszerben ez a 165-ös számnak felel meg. Nézzük meg, helyesek-e a számításaink:

public class Main {

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

Konzol kimenet: 165 Szuper! Minden úgy van, ahogy gondoltuk :) Most itt az ideje, hogy megismerkedjünk a bit shift operátorokkal. A név magáért beszél. Vegyünk egy számot, és mozgassuk a bitjeit balra vagy jobbra :) Lássuk, hogyan néz ki:

Váltás balra

A bitek balra tolódását a << Íme egy példa:

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

Ebben a példában az x = 64 számot értéknek nevezzük. Az érték azon részeit fogjuk eltolni. A biteket balra toljuk (ezt a << operátor irányából sejthettük ) A bináris rendszerben a 64 = 1000000 számot Az y = 3 számot eltolási távolságnak nevezzük. Az eltolási távolság azt jelzi, hogy hány bittel kívánja jobbra/balra tolni az x szám bitjeit Példánkban 3 bittel balra toljuk el. Ha tisztábban szeretné látni az eltolási folyamatot, nézze meg a képet. Ebben a példában az int s-t használjuk . Az Ints 32 bitet foglal el a számítógép memóriájában. Így néz ki az eredeti 64-es számunk: És most fogjuk mindegyik bitünket, és szó szerint 3 hellyel balra toljuk: Nézze meg, mit kaptunk. Amint látható, minden bitünk eltolódott, és újabb 3 nulla került hozzáadásra a tartomány széléről. Három, mert eltoltunk 3-mal. Ha 10-el toltuk volna, akkor 10 nulla lett volna hozzáadva. Így az x << y kifejezés azt jelenti, hogy "az x szám bitjeit y hellyel balra toljuk". Kifejezésünk eredménye a 1000000000 szám, ami decimális rendszerben 512. Ellenőrizzük:

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

Konzol kimenet: 512 Spot on! Elméletileg a bitek végtelenségig eltolhatók, de mivel a számunk egy int , csak 32 bináris számjegy áll rendelkezésünkre. Ebből 7-et már 64-en (1000000) foglaltak el. Ezért ha 27 hellyel balra tolnánk, a mi egyetlenünk túllépne az adattípus tartományán, és elveszne. Csak nullák maradnának!

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

Konzol kimenet: 0 Ahogy az várható volt, az egyik túllépte a 32 elérhető bitet, és eltűnt. Egy 32 bites számmal fejeztük be, amely csak nullákból áll. Ez természetesen 0-nak felel meg a decimális rendszerben. Íme egy egyszerű szabály a balra tolások emlékezésére: Minden balra tolódásnál a számot megszorozzuk 2-vel. Próbáljuk meg kiszámítani a következő kifejezést bitek képei nélkül: 111111111 << 3 Az 111111111 számot meg kell szoroznunk 2-vel. Ennek eredményeként 888888888-at kapunk. Írjunk egy kódot, és ellenőrizzük:

public class Main {

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

Konzol kimenet: 888888888

Váltás jobbra

Ezt a műveletet >> jelöli . Ugyanezt csinálja, csak a másik irányba! :) Nem fogjuk feltalálni újra a kereket. Próbáljuk meg ugyanazzal az int 64-el.

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

A 2-vel jobbra való eltolódás eredményeként a számunkban szereplő két szélső nulla kimozdul a tartományból és elveszik. 10000-et kapunk, ami a 16-os számnak felel meg a decimális rendszerben. Konzol kimenete: 16 Íme egy egyszerű szabály a jobbra tolások emlékezésére: Minden jobbra eltolás osztódik kettővel, a maradékot eldobva. Például a 35 >> 2 azt jelenti, hogy a 35-öt kétszer el kell osztanunk 2-vel, a maradékot el kell dobnunk 35/2 = 17 (a maradék 1 eldobása) 17/2 = 8 (a maradék 1 eldobása) A végén 35 >> 2 kell egyenlő legyen 8-cal. Ellenőrizzük:

public class Main {

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

Konzol kimenet: 8

Operátori elsőbbség Java-ban

A kód írása és olvasása közben gyakran találhat olyan kifejezéseket, amelyek több műveletet kombinálnak. Nagyon fontos megérteni, hogy milyen sorrendben fognak végrehajtani (ellenkező esetben meglepődhet az eredmény). Mivel a Java sok művelettel rendelkezik, mindegyik egy speciális táblában van kijelölve:

Üzemeltetői elsőbbség

Minden művelet balról jobbra történik, figyelembe véve azok elsőbbségét. Például ha azt írjuk

int x  = 6 - 4/2;

akkor először az osztási művelet ( 4/2 ) kerül végrehajtásra. Bár második helyen áll, magasabb a prioritása. A zárójelek és a zárójelek a maximális elsőbbséget jelzik. Valószínűleg emlékszel rá az iskolából. Például, ha hozzáadja őket a kifejezéshez

int x  = (6 - 4)/2;

akkor először a kivonás történik, mivel az zárójelben van. A logikai && operátor elsőbbsége meglehetősen alacsony (lásd a táblázatot), így általában az utolsó lesz. Például:

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

Ez a kifejezés a következőképpen kerül végrehajtásra:

• 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;

Ezután az összehasonlító operátorok végrehajtásra kerülnek:

• 4 > 3 = igaz

boolean x = true && 144 <= 119;

• 144 <= 119 = hamis

boolean x = true && false;

És végül az ÉS operátor ( && ) kerül végrehajtásra utoljára.

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

Például az összeadás( + ) operátornak magasabb a prioritása, mint a != (nem egyenlő) összehasonlító operátornak; Ezért a kifejezésben

boolean x = 7 != 6+1;

először a 6+1 műveletet hajtjuk végre, majd a 7 != 7 ellenőrzést (ami hamisra értékel), végül az eredmény hozzárendelését (hamis) az x változóhoz (a hozzárendelésnek általában a legalacsonyabb a prioritása az összes operátor közül; ld. az asztal). Fú! Hatalmas lecke volt, de megcsináltad! Ha nem értette meg teljesen ezt vagy az előző leckéket, ne aggódjon. Ezeket a témákat a jövőben többször is érinteni fogjuk. Néhány CodeGym lecke a logikai és numerikus műveletekről. Ezekre egyhamar nem fogunk rátérni, de nem árt, ha most elolvasod őket.