Mga operator ng Java Bitwise

Sa aralin ngayon, makikilala natin ang Java Bitwise Operators at isaalang-alang ang mga halimbawa kung paano magtrabaho sa kanila. Marahil ay pamilyar ka sa salitang "bit". Kung hindi, alalahanin natin kung ano ang ibig sabihin nito :) Ang bit ay ang pinakamaliit na yunit ng impormasyon sa isang computer. Ang pangalan nito ay nagmula sa binary digit . Ang isang bit ay maaaring ipahayag ng isa sa dalawang numero: 1 o 0. Mayroong espesyal na sistema ng binary na numero batay sa mga isa at mga zero. Hindi tayo sisilip sa isang mathematical jungle dito. Mapapansin lang namin na ang anumang numero sa Java ay maaaring ma-convert sa binary form. Upang gawin ito, kailangan mong gamitin ang mga klase ng wrapper. Halimbawa, narito kung paano mo ito magagawa para sa isang int :

public class Main {

   public static void main(String[] args) {

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

Output ng console: 101010110 1010 10110 (Idinagdag ko ang espasyo para mas madaling basahin) ay ang numerong 342 sa decimal system. Talagang hinati namin ang numerong ito sa mga indibidwal na piraso: mga zero at isa. Ang mga operasyong isinagawa sa mga bit ay tinatawag na bitwise .

• ~ - bitwise HINDI.

Ang operator na ito ay napaka-simple: ipinapasa nito ang bawat bit ng aming numero, at pinipitik ang bit: ang mga zero ay nagiging isa, at ang mga isa ay nagiging mga zero. Kung ilalapat natin ito sa ating numerong 342, narito ang mangyayari: 101010110 ay 342 na kinakatawan bilang isang binary na numero 010101001 ang halaga ng expression ~342 Subukan nating isabuhay ito:

public class Main {

   public static void main(String[] args) {

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

Output ng console: 169 169 ang aming resulta ( 010101001 ) sa pamilyar, decimal system :)

• & - bitwise AT

Tulad ng nakikita mo, mukhang halos kapareho ito ng lohikal na AND ( && ). Ang && operator, maaalala mo, ay nagbabalik lamang ng true kung ang parehong mga operand ay totoo. Bitwise at gumagana sa katulad na paraan: inihahambing nito ang dalawang numero nang paunti-unti. Ang paghahambing ay gumagawa ng ikatlong numero. Halimbawa, kunin natin ang mga numerong 277 at 432: Ang 110110000 ay 277 na kinakatawan bilang isang binary na numero 1000101011 ay 432 na kinakatawan bilang isang binary na numero. Dahil ito ay isang AND operator, ang resulta ay magiging 1 lamang kung ang parehong mga bit ay 1. Sa anumang iba pang kaso, ang resulta ay 0. 100010101 && operator Una, pinagkukumpara namin ang mga unang bit ng dalawang numero, pagkatapos ay ang pangalawang bit, pagkatapos ay ang pangatlo, at iba pa. Tulad ng nakikita mo, sa dalawang kaso lamang ay parehong katumbas na mga bit sa mga numero na katumbas ng 1 (ang una at ikalimang bit). Ang lahat ng iba pang paghahambing ay gumawa ng 0s. Kaya sa huli nakuha namin ang numerong 10001000. Sa sistema ng decimal, tumutugma ito sa numerong 272. Suriin natin:

public class Main {

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

Output ng console: 272

• | - bitwise O.

Gumagana ang operator na ito sa parehong paraan: paghahambing ng dalawang numero nang paunti-unti. Ngayon lang kung kahit isa sa mga bit ay 1, ang resulta ay 1. Tingnan natin ang parehong mga numero (277 at 432): 100010101 | 110110000 _______________ 110110101 - resulta ng | operator Narito ang nakakakuha tayo ng ibang resulta: ang tanging mga bit na nananatiling mga zero ay ang mga bit na naging mga zero sa parehong mga numero. Ang resulta ay ang numerong 110110101. Sa sistema ng decimal, tumutugma ito sa numerong 437 Suriin natin:

public class Main {

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

Output ng console: 437 Nakalkula namin nang tama ang lahat! :)

• ^ - bitwise XOR (eksklusibo O)

Hindi pa namin nakakaharap ang operator na ito. Ngunit walang kumplikado tungkol dito. Ito ay katulad ng ordinaryong O operator. May isang pagkakaiba: ang ordinaryong OR ay nagbabalik ng true kung kahit isang operand ay totoo. Ngunit hindi ito kailangang maging isa: kung ang parehong mga operand ay totoo, ang resulta ay totoo. Ngunit ang eksklusibong OR ay nagbabalik lamang ng totoo kung ang eksaktong isa sa mga operand ay totoo. Kung ang parehong operand ay totoo, ang ordinaryong OR ay nagbabalik ng true ("kahit isang true"), ngunit ang XOR ay nagbabalik ng false. Kaya naman tinawag itong exclusive OR. Alam kung paano gumagana ang mga nakaraang bitwise operator, malamang na madali mong kalkulahin ang 277 ^ 432. Ngunit pag-aralan natin ito ng isa pang beses :) 100010101 ^ 110110000 _______________ 010100101 - resulta ng ^operator Iyan ang aming resulta. Ang mga bit na iyon na pareho sa parehong numero ay gumagawa ng 0 (ibig sabihin, nabigo ang "isa lang" na pagsubok). Ngunit ang mga piraso na bumuo ng isang 0-1 o 1-0 na pares ay naging isa. Ang aming resulta ay ang numerong 010100101. Sa sistema ng decimal, tumutugma ito sa numerong 165. Tingnan natin kung tama ang aming mga kalkulasyon:

public class Main {

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

Output ng console: 165 Super! Ang lahat ay tulad ng naisip namin :) Ngayon ay oras na upang maging pamilyar sa mga bit shift operator. Ang pangalan ay nagsasalita para sa sarili nito. Kumuha kami ng ilang numero, at inililipat ang mga bit nito pakaliwa o pakanan :) Tingnan natin kung ano ang hitsura nito:

Lumipat pakaliwa

Ang paglipat ng mga bit sa kaliwa ay ipinahiwatig ng << Narito ang isang halimbawa:

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

Sa halimbawang ito, ang numerong x = 64 ay tinatawag na halaga. Ito ang mga piraso ng halaga na ililipat natin. Ililipat namin ang mga bits sa kaliwa (maaaring nahulaan mo ito sa direksyon ng << operator) Sa binary system, ang numero 64 = 1000000 Ang numerong y = 3 ay tinatawag na shift distance. Ang distansya ng shift ay nagpapahiwatig kung gaano karaming mga bit sa kanan/kaliwa ang gusto mong ilipat ang mga bit ng numerong x Sa aming halimbawa, ililipat namin ang mga ito ng 3 bits sa kaliwa. Upang mas malinaw na makita ang proseso ng paglilipat, tingnan ang larawan. Sa halimbawang ito, ginagamit namin ang int s. Ang mga ints ay sumasakop ng 32 bits sa memorya ng computer. Ganito ang hitsura ng aming orihinal na numero 64: At ngayon kinuha namin ang bawat isa sa aming mga bit at literal na inilipat ang mga ito sa kaliwa ng 3 lugar: Tingnan kung ano ang nakuha namin. Tulad ng nakikita mo, lahat ng aming mga bit ay lumipat, at isa pang 3 zero ang naidagdag mula sa gilid ng hanay. Tatlo, dahil nag-shift kami ng 3. Kung nag-shift kami ng 10, 10 zeros sana ang nadagdag. Kaya, ang expression na x << y ay nangangahulugang "ilipat ang mga bit ng numerong x sa kaliwa ng y na lugar". Ang resulta ng aming expression ay ang bilang ng 1000000000, na 512 sa decimal system. Suriin natin:

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

Output ng console: 512 Spot on! Sa teorya, ang mga bit ay maaaring ilipat nang walang katapusan, ngunit dahil ang aming numero ay isang int , mayroon lamang kaming 32 binary digit na magagamit. Sa mga ito, 7 ay inookupahan na ng 64 (1000000). Samakatuwid, kung ililipat namin ang 27 na lugar sa kaliwa, ang isa lang namin ay lalampas sa saklaw ng uri ng data at mawawala. Mga zero lang ang mananatili!

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

Output ng console: 0 Gaya ng inaasahan, ang isa ay lumampas sa 32 available na bit at nawala. Nagtapos kami sa isang 32-bit na numero na binubuo lamang ng mga zero. Naturally, ito ay tumutugma sa 0 sa decimal system. Narito ang isang simpleng panuntunan para sa pag-alala ng mga shift sa kaliwa: Para sa bawat shift sa kaliwa, ang numero ay i-multiply sa 2. Subukan nating kalkulahin ang sumusunod na expression na walang mga larawan ng mga bit 111111111 << 3 Kailangan nating i-multiply ang numerong 111111111 sa 2 . Bilang resulta, nakakakuha tayo ng 888888888. Sumulat tayo ng ilang code at suriin:

public class Main {

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

Output ng console: 888888888

Lumipat pakanan

Ang operasyong ito ay tinutukoy ng >> . Ginagawa nito ang parehong bagay, ngunit sa kabilang direksyon! :) Hindi namin muling iimbento ang gulong. Subukan natin ito sa parehong 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);
   }
}

Bilang resulta ng paglipat sa kanan ng 2, ang dalawang matinding zero sa aming numero ay lumalabas sa saklaw at nawala. Makakakuha tayo ng 10000, na tumutugma sa numerong 16 sa decimal system na Console na output: 16 Narito ang isang simpleng panuntunan para sa pag-alala ng mga shift sa kanan: Ang bawat shift sa kanan ay nahahati sa dalawa, na itinatapon ang anumang natitira. Halimbawa, ang 35 >> 2 ay nangangahulugan na kailangan nating hatiin ang 35 sa 2 ng dalawang beses, itapon ang mga natitira 35/2 = 17 (itapon ang natitira 1) 17/2 = 8 (itapon ang natitira 1) Sa huli, 35 >> 2 ang dapat maging katumbas ng 8. Suriin natin:

public class Main {

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

Output ng console: 8

Pangunahing operator sa Java

Habang nagsusulat at nagbabasa ng code, madalas kang makakahanap ng mga expression na pinagsasama ang ilang mga operasyon. Napakahalagang maunawaan ang pagkakasunud-sunod kung saan ipapatupad ang mga ito (kung hindi man, mabigla ka sa resulta) Dahil maraming operasyon ang Java, ang bawat isa sa kanila ay itinalaga ng isang lugar sa isang espesyal na talahanayan:

Pangunahing Operator

Ang lahat ng mga operasyon ay isinasagawa mula kaliwa hanggang kanan, na isinasaalang-alang ang kanilang nangunguna. Halimbawa, kung magsusulat tayo

int x  = 6 - 4/2;

pagkatapos ay ang operasyon ng paghahati ( 4/2 ) ay isasagawa muna. Bagama't ito ay pumapangalawa, ito ay may mas mataas na precedence. Ang mga panaklong at mga bracket ay nagpapahiwatig ng pinakamataas na precedence. Malamang naaalala mo iyon mula sa paaralan. Halimbawa, kung idaragdag mo sila sa expression

int x  = (6 - 4)/2;

pagkatapos ay gagawin muna ang pagbabawas, dahil ito ay nakapaloob sa mga panaklong. Ang precedence ng lohikal na && operator ay medyo mababa (tingnan ang talahanayan), kaya kadalasan ito ang huli. Halimbawa:

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

Ang expression na ito ay isasagawa tulad ng sumusunod:

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

Susunod, ang mga operator ng paghahambing ay isinasagawa:

• 4 > 3 = totoo

boolean x = true && 144 <= 119;

• 144 <= 119 = mali

boolean x = true && false;

At, sa wakas, ang AND operator ( && ) ay huling isasagawa.

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

Halimbawa, ang addition( + ) operator ay may mas mataas na precedence kaysa sa != (not equal) comparison operator; Samakatuwid, sa pagpapahayag

boolean x = 7 != 6+1;

ang 6+1 na operasyon ay unang isasagawa, pagkatapos ay ang 7 != 7 na tseke (na nagsusuri sa false), at sa wakas ay ang pagtatalaga ng resulta (false) sa variable na x (ang pagtatalaga sa pangkalahatan ay may pinakamababang nauuna sa lahat ng mga operator; tingnan ang ang lamesa). Phew! Ito ay isang malaking aral, ngunit ginawa mo ito! Kung hindi mo lubos na nauunawaan ang ilan sa mga ito o mga nakaraang aralin, huwag mag-alala. Tatalakayin namin ang mga paksang ito nang higit sa isang beses sa hinaharap. Isang pares ng mga aralin sa CodeGym tungkol sa mga lohikal at numerical na operasyon. Hindi na kami makakarating sa mga ito sa lalong madaling panahon, ngunit walang masama kung basahin mo ang mga ito ngayon.