Panimula sa Java Operators: Logical, Arithmetic, Bitwise

Pag-usapan natin ang tungkol sa mga operasyon sa Java: numeric, logical, bitwise. Ito ay isang teoretikal na batayan na tiyak na kailangan upang malaman kung paano magprograma.

• Ano ang mga uri ng mga operator sa Java?
• Mga Java Operator sa JavaRush Course
• Mga pagpapatakbo ng numero sa Java
• Mga Lohikal na Operasyon sa Java
• Bitwise na operasyon sa Java
• Nangunguna sa mga operasyon sa Java
• Mga kapaki-pakinabang na halimbawa ng paggamit

Ano ang mga uri ng mga operator sa Java?

Para sa anumang operasyon kailangan namin ng hindi bababa sa dalawang bagay:

• operator;
• operand.

Ang isang halimbawa ng isang operator ay isang simpleng plus sa pagpapatakbo ng pagdaragdag ng dalawang numero. At ang mga numerong idinagdag sa isa't isa ay magiging mga operand sa kasong ito. Kaya, sa tulong ng mga operator, nagsasagawa kami ng mga operasyon sa isa o higit pang mga operand. Ang mga operator na nagsasagawa ng mga operasyon sa dalawang operand ay tinatawag na binary. Halimbawa, pagdaragdag ng dalawang numero. Ang mga operator na nagsasagawa ng mga operasyon sa isang solong operand ay tinatawag na unary. Halimbawa, isang unary minus.

Mga Java Operator sa JavaRush Course

Ang ilang mga lektura ay nakatuon sa mga operator ng Java sa ikaapat na antas ng unang paghahanap - Java Syntax. Sa partikular, ang mga may kondisyong operator gaya ng boolean . Ang kurso ay naglalaman ng 22 mga gawain na tutulong sa iyo na maunawaan ang gawain ng mga operator ng paghahambing, mga operator na may kondisyon, at mga lohikal na operator.

Mga pagpapatakbo ng numero sa Java

Ang pinakakaraniwang operasyon na ginagawa ng mga programmer sa mga numero ay ang pagtatalaga ng numeric na halaga sa isang variable. Siya, tulad ng operator, =ay pamilyar sa iyo:

int a = 1;
int b = 2;
int c = 3;

Mayroon ding mga arithmetic operations. Isinasagawa ang mga ito gamit ang binary arithmetic operator: Talahanayan 1. Binary arithmetic operators Ang unang apat na operator ay hindi dapat magtaas ng anumang mga katanungan: ang lahat ay kapareho ng sa matematika. Ang huling operator, ang natitira sa dibisyon, ay hindi rin gumagawa ng anumang bagay na masyadong kumplikado. Halimbawa, kung hahatiin natin ang 24 sa 7, makakakuha tayo ng 3 buong numero at 3 natitira. Ang natitira ay ibabalik ng operator na ito:

System.out.println(24 % 7); // prints 3

Narito ang mga halimbawa mula sa opisyal na site ng dokumentasyon ng Oracle: Ilalabas ng program na ito ang sumusunod: 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4/2 = 2 2 + 8 = 10 10 % 7 = 3 Pinapayagan ka ng Java upang pagsamahin: halimbawa, mga pagtatalaga ng operator at mga operator ng aritmetika. Tingnan natin ang isang halimbawa:

int x = 0;
x = x + 1; // x = 0 + 1 => x = 1
x = x + 1; // x = 1 + 1 => x = 2
x = x + 1; // x = 2 + 1 => x = 3

Dito namin tinukoy ang isang variable xat itinalaga ito ng isang halaga ng zero. Susunod, sa bawat linya ay nagtatalaga kami ng halaga xsa kabuuan ng kasalukuyang halaga ng variable xat isa. May mga paliwanag sa mga komento para sa bawat linya. Ang pamamaraang ito ay tinatawag na paglaki o pagdaragdag ng isang variable. Ang pagdaragdag na operasyon mula sa halimbawa sa itaas ay maaaring mapalitan ng isang katulad gamit ang kumbinasyon ng mga operator:

int x = 0;
x += 1; // x = 0 + 1 => x = 1
x += 1; // x = 1 + 1 => x = 2
x += 1; // x = 2 + 1 => x = 3

Maaari mong pagsamahin ang assignment operator sa anumang arithmetic operator:

int x = 0;
x += 10; // x = 0 + 10 => x = 10
x -= 5; // x = 10 - 5 => x = 5
x *= 5; // x = 5 * 5 => x = 25
x /= 5; // x = 25 / 5 => x = 5
x %= 3; // x = 5 % 3 => x = 2;

Ipakita natin kung paano gumagana ang huling halimbawa: Bilang karagdagan sa mga binary operator, ang Java ay may unary arithmetic operator. Talahanayan 2. Unary arithmetic operator: Halimbawa ng unary plus at minus:

int x = 0;
x = (+5) + (+15); // Parentheses for clarity, it is possible without them
System.out.println("x = " + x);

int y = -x;
System.out.println("y = " + y);

Ang mga pagpapatakbo ng pagdaragdag at pagbabawas ay mahalagang simple. Sa unang kaso, ang variable ay nadagdagan ng 1, sa pangalawa, ang variable ay nababawasan ng 1. Ang halimbawa ay nasa ibaba:

int x = 9;
x++;
System.out.println(x); // 10

int y = 21;
y--;
System.out.println(y); // 20

Mayroong dalawang uri ng mga operasyong ito - postfix at prefix. Sa unang kaso, ang operator ay isinulat pagkatapos ng variable, sa pangalawang kaso, bago ang variable. Ang kaibahan lang ay kapag ang increment o decrement operation ay ginawa. Halimbawa at paglalarawan sa talahanayan sa ibaba. Sabihin nating mayroon tayong variable:

int a = 2;

Pagkatapos: Talahanayan 3. Mga operator ng pagtaas-bawas: Pagpapakita: Bilang karagdagan sa aritmetika, mayroong mga pagpapatakbo ng paghahambing (ng dalawang numero). Ang resulta ay palaging totoo o mali ( true / false ). Talahanayan 4. Mga operator ng paghahambing Mga halimbawa:

int a = 1;
int b = 2;

boolean comparisonResult = a == b;
System.out.println("a == b :" + comparisonResult);

comparisonResult = a != b;
System.out.println("a != b :" + comparisonResult);

comparisonResult = a > b;
System.out.println("a >  b :" + comparisonResult);

comparisonResult = a >= b;
System.out.println("a >= b :" + comparisonResult);

comparisonResult = a < b;
System.out.println("a <  b :" + comparisonResult);

comparisonResult = a <= b;
System.out.println("a <= b :" + comparisonResult);

Pagpapakita:

Mga Lohikal na Operasyon sa Java

Tingnan natin ang mga lohikal na operasyon at mga talahanayan ng katotohanan ng bawat isa sa kanila:

• pagpapatakbo ng negation ( NOT);
• operasyong pang-ugnay, lohikal AT ( AND);
• pagpapatakbo ng disjunction, lohikal O ( OR);
• pagpapatakbo ng pagdaragdag ng modulo, eksklusibo O ( XOR).

Ang negation operator ay unary at nalalapat sa isang solong operand. Ang lahat ng iba pang mga operasyon ay binary. Isaalang-alang natin ang mga talahanayan ng katotohanan ng mga operasyong ito. Narito ang 0 ay ang katumbas ng false sa Java, at ang 1 ay ang katumbas ng true . Talahanayan 5. Negation Operator Truth Table (NOT) Talahanayan 6. Talahanayan ng katotohanan ng conjunction operator (AND) Talahanayan 7. Talahanayan ng katotohanan ng disjunction operator (OR) Talahanayan 8. Talahanayan ng katotohanan ng modulo addition operator (XOR) Ang Java ay may parehong lohikal na operasyon:

• !- operator ng pagtanggi;
• &&— lohikal AT operator (maikli);
• ||— lohikal O operator (maikli);
• &— bitwise AT operator;
• |— bitwise O operator;
• ^— bitwise eksklusibo O operator.

Tingnan natin ang pagkakaiba sa pagitan ng bitwise at shorthand operator nang kaunti pa sa ibaba, habang i-convert natin ang lahat ng mga talahanayan ng katotohanan sa Java code:

public class LogicDemo {

   public static void main(String[] args) {
    notExample();
    andExample();
    orExample();
    xorExample();
   }

   public static void notExample() {
    System.out.println("NOT EXAMPLE:");
    System.out.println("NOT false = " + !false);
       System.out.println("NOT true  = " + !true);
    System.out.println();
   }

   public static void andExample() {
    System.out.println("AND EXAMPLE:");
    System.out.println("false AND false = " + (false & false));
    System.out.println("false AND true  = " + (false & true));
    System.out.println("true  AND false = " + (true & false));
    System.out.println("true  AND true  = " + (true & true));
    System.out.println();
   }

   public static void orExample() {
    System.out.println("OR EXAMPLE:");
    System.out.println("false OR false = " + (false | false));
    System.out.println("false OR true  = " + (false | true));
    System.out.println("true  OR false = " + (true | false));
     System.out.println("true  OR true  = " + (true | true));
    System.out.println();
   }

   public static void xorExample() {
    System.out.println("XOR EXAMPLE:");
    System.out.println("false XOR false = " + (false ^ false));
    System.out.println("false XOR true  = " + (false ^ true));
    System.out.println("true  XOR false = " + (true ^ false));
    System.out.println("true  XOR true  = " + (true ^ true));
    System.out.println();
   }
}

Ipapakita ng program na ito ang: HINDI HALIMBAWA: HINDI mali = totoo HINDI totoo = mali AT HALIMBAWA: mali AT mali = mali mali AT totoo = mali totoo AT mali = mali totoo AT totoo = totoo O HALIMBAWA: mali O mali = mali mali O totoo = true true OR false = true true OR true = true XOR EXAMPLE: false XOR false = false false XOR true = true true XOR false = true true XOR true = false Ang mga lohikal na operator ay nalalapat lamang sa booleanmga variable. Sa aming kaso, direktang inilapat namin ang mga ito sa mga halaga, ngunit maaari mo ring gamitin ang mga ito sa booleanmga variable: At sa booleanmga expression: Ngayon, mayroon kaming shorthand operator ( &&, ||) at katulad na bitwise operators ( &, |). Ano ang pagkakaiba sa pagitan nila? Una, maaaring mailapat ang bitwise sa mga integer. Pag-uusapan natin ito mamaya. At pangalawa, ang ilan ay pinaikli, habang ang iba ay hindi. Upang maunawaan kung ano ang hitsura ng abbreviation, tingnan natin ang expression:

false AND x = ?
true OR x = ?

Maaari itong xtumagal ng anumang Boolean na halaga. At sa pangkalahatan, ayon sa mga batas ng lohika at mga talahanayan ng katotohanan, hindi alintana kung ito ay x totoo o mali , ang resulta ng unang pagpapahayag ay magiging mali , at ang resulta ng pangalawa ay magiging totoo . Tingnan mo. Minsan ang resulta ng isang expression ay maaaring kalkulahin mula sa unang operand. Ito ang nagpapakilala sa mga pinaikling operator &&at ||. Sa mga expression na katulad ng mga inilarawan sa itaas, hindi nila sinusuri ang halaga ng pangalawang operand. Narito ang isang maliit na halimbawa: Sa kaso ng mga shorthand operator, ang pangalawang bahagi ng expression ay hindi sinusuri. Ngunit ito ay nangyayari lamang kapag ang resulta ng expression ay halata na mula sa unang operand.

Bitwise na operasyon sa Java

Buweno, narito tayo sa pinakakawili-wiling bahagi: mga bitwise na operasyon. Tulad ng iminumungkahi ng pangalan, ito ay mga operasyon na ginagawa sa mga bit. Ngunit bago tayo sumisid sa paksang ito, sulit na pag-usapan ang mga kaugnay na lugar.

Representasyon ng mga numero sa binary number system

Ang mga numero, tulad ng anumang iba pang impormasyon sa isang programa, ay naka-imbak sa memorya ng computer sa binary code. Ang binary code ay isang set ng mga zero at isa. Ang bawat zero o isa ay kumakatawan sa isang yunit ng impormasyon na tinatawag na bit.

Ayon sa Wikipedia:

Ang kaunti (mula sa Ingles na binary digit - binary number; isa ring play sa mga salita: English bit - piece, particle) ay isang yunit ng pagsukat ng dami ng impormasyon. Ang 1 bit ng impormasyon ay isang simbolo o signal na maaaring magkaroon ng dalawang kahulugan: on or off, yes or no, high or low, charged or uncharged; sa binary system ito ay 1 (isa) o 0 (zero).

Anong uri ng data ang gumagana sa mga bitwise operator?

Ang mga bitwise na operasyon sa Java ay ginagawa lamang sa mga integer. Ang mga integer ay iniimbak sa memorya ng computer bilang isang set ng mga bit. Maaari nating sabihin na ang isang computer ay nagko-convert ng anumang impormasyon sa isang binary number system (isang set ng mga bit) at pagkatapos lamang ay nakikipag-ugnayan dito. Ngunit paano gumagana ang binary number system? Sa sistema ng decimal na numero mayroon lamang tayong 10 simbolo: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Ginagamit namin ang mga simbolo na ito upang mabilang. Pagkatapos ng 9 ay 10, pagkatapos ng 19 - 20, pagkatapos ng 99 - 100, pagkatapos ng 749 - 750. Ibig sabihin, gumagamit kami ng kumbinasyon ng available na 10 simbolo at magagamit namin ang mga ito upang mabilang "mula sa zero hanggang tanghalian." Sa binary number system, sa halip na sampung simbolo, mayroon lamang dalawa - 0, 1. Ngunit sa pamamagitan ng pagsasama-sama ng mga simbolo na ito ayon sa parehong prinsipyo tulad ng sa decimal system, mabibilang tayo nang walang katiyakan. Ipakita natin ang pagbibilang mula 0 hanggang 15 sa decimal at binary: Tulad ng nakikita mo, ang lahat ay hindi masyadong kumplikado. Bilang karagdagan sa mga bit, may iba pang pamilyar na mga yunit ng impormasyon - bytes , kilobytes , megabytes , gigabytes , atbp. Malamang alam mo na mayroong 8 bits sa 1 byte . Ano ang ibig sabihin nito? Nangangahulugan ito na ang 8 bits sa isang hilera ay sumasakop sa 1 byte. Narito ang mga halimbawa ng kung ano ang maaaring maging mga byte:

00000000 - 1 byte
10110010 - 1 byte
01011011 - 1 byte

Ang bilang ng mga posibleng hindi umuulit na kumbinasyon ng mga bit sa isang byte ay 256 (2 ⁸ = 256). Ngunit bumalik tayo nang mas malapit sa Java. Mayroong ganitong uri ng data ng integer - byte. Ang ganitong uri ay maaaring tumagal ng mga halaga mula -128 hanggang 127 at ang isang numero sa memorya ng computer ay tumatagal ng eksaktong 8 bits, o 1 byte. Ang isang numero ng ganitong uri ay tumatagal ng eksaktong 1 bytememorya ng computer. At dito ang mga pangalan ay hindi nagkataon. Tulad ng naaalala namin, ang 1 byte ay maaaring mag-imbak ng 256 iba't ibang mga halaga. At ang isang uri ng numero byteay maaaring tumagal sa 256 iba't ibang mga halaga (128 negatibo, 127 positibo at 1 zero). Ang bawat halaga ng numero byteay may natatanging hanay ng walong bits. Ito ang kaso hindi lamang sa type byte, ngunit sa lahat ng integral na uri. Ang uri byteay ibinigay bilang isang halimbawa bilang ang pinakamaliit. Ipinapakita ng talahanayan sa ibaba ang lahat ng mga uri ng Java integer at ang espasyo ng memorya na sinasakop nila: Isaalang-alang ang uri int. Maaari itong mag-imbak ng 2147483648 negatibong halaga, 2147483647 positibong halaga, at isang zero. Kabuuan:

2147483648 + 2147483647 + 1 = 4294967296.

Ang ganitong uri ay tumatagal ng hanggang 32 bits sa memorya ng computer. Ang bilang ng mga posibleng kumbinasyon mula sa isang set ng 32 zero at isa ay:

232 = 4294967296.

Ang parehong bilang ng bilang ng mga halaga na maaaring hawakan ng uri int. Ito ay isang pagpapakita lamang ng kaugnayan sa pagitan ng hanay ng mga halaga ng isang uri ng data at laki nito (bilang ng mga bit sa memorya). Ang anumang numero ng anumang uri sa Java ay maaaring ma-convert sa binary. Tingnan natin kung gaano kadali ito magagawa gamit ang wikang Java. Matututo tayo mula sa halimbawa ng uri int. Ang uri na ito ay may sariling klase ng wrapper - Integer. At mayroon siyang isa toBinaryString, na gagawa ng lahat ng gawain para sa atin: Voila - hindi ganoon kakomplikado. Ngunit gayon pa man, may kailangang linawin. intang numero ay tumatagal ng 32 bits. Ngunit kapag nag-print kami ng numero 10 sa halimbawa sa itaas, makikita namin ang 1010 sa console. Ito ay dahil hindi naka-print ang mga nangungunang zero. Kung ipinakita ang mga ito, sa halip na 1010 ay makikita natin sa console ang 000000000000000000000000000001010. Ngunit para sa kadalian ng pang-unawa, lahat ng nangungunang mga zero ay tinanggal. Hindi ganoon kahirap hanggang sa tanungin mo ang iyong sarili: paano naman ang mga negatibong numero? Nakikita lamang nito ang impormasyon sa binary system. Ito ay lumiliko na ang minus sign ay kailangan ding isulat sa binary code. Magagawa ito gamit ang direkta o komplementaryong code.

Direktang code

Isang paraan ng pagre-represent ng mga numero sa binary number system, kung saan ang pinaka makabuluhang bit (ang pinakakaliwang bit) ay inilalaan sa sign ng numero. Kung positibo ang numero, ang pinakakaliwang bit ay nakasulat na 0, kung negatibo - 1. Tingnan natin ito gamit ang isang 8-bit na numero bilang isang halimbawa: Ang diskarte ay simple at, sa prinsipyo, naiintindihan. Gayunpaman, mayroon itong mga disadvantages: mga kahirapan sa pagsasagawa ng mga operasyong matematika. Halimbawa, sa pagdaragdag ng negatibo at positibong mga numero. Hindi sila maaaring itiklop maliban kung ang mga karagdagang pagmamanipula ay isinasagawa.

Karagdagang code

Sa pamamagitan ng paggamit ng karagdagang code, maiiwasan mo ang mga disadvantage ng direktang code. Mayroong isang simpleng algorithm upang makuha ang karagdagang code ng isang numero. Subukan nating kunin ang karagdagang code para sa numero -5. Katawanin natin ang numerong ito gamit ang complement code ng dalawa sa binary number system. Hakbang 1. Kumuha kami ng representasyon ng isang negatibong numero gamit ang direktang code. Para sa -5 ito ay magiging 10000101. Hakbang 2. Baligtarin ang lahat ng digit maliban sa sign digit. Palitan natin ang lahat ng mga zero ng isa, at ang mga may mga zero sa lahat ng dako maliban sa pinakakaliwang bit.

10000101 => 11111010

Hakbang 3. Magdagdag ng isa sa resultang halaga:

11111010 + 1 = 11111011

handa na. Nakuha namin ang halaga ng -5 sa binary number system gamit ang complement code ng dalawa. Mahalaga ito para sa pag-unawa sa sumusunod na materyal, dahil gumagamit ang Java ng complement code ng dalawa upang mag-imbak ng mga negatibong numero sa mga bit.

Mga uri ng bitwise na operasyon

Ngayon na napag-usapan na natin ang lahat ng mga pagpapakilala, pag-usapan natin ang tungkol sa mga bitwise na operasyon sa Java. Ang isang bitwise na operasyon ay isinasagawa sa mga integer at ang resulta nito ay isang integer. Sa proseso, ang numero ay na-convert sa binary, isang operasyon ay isinasagawa sa bawat bit, at ang resulta ay na-convert pabalik sa decimal. Ang listahan ng mga operasyon ay nasa talahanayan sa ibaba: Tulad ng nalaman na natin, ang mga numero ay maaaring katawanin bilang isang set ng mga bit. Ang mga bitwise na operasyon ay nagsasagawa ng mga operasyon sa eksaktong bawat bit ng naturang representasyon. Kunin natin NOT, AND, OR, XOR. Alalahanin na kamakailan lamang ay tumingin kami sa mga talahanayan ng katotohanan para lamang sa mga lohikal na operand. Sa kasong ito, ang parehong mga operasyon ay inilalapat sa bawat bit ng integer.

Bitwise unary operator HINDI ~

Pinapalitan ng operator na ito ang lahat ng mga zero ng isa, at lahat ng mga ito ay may mga zero. Sabihin nating mayroon tayong numerong 10 sa decimal notation. Sa binary, ang numerong ito ay 1010. Kung ilalapat natin ang unary bitwise negation operator sa numerong ito, makakakuha tayo ng ganito: Tingnan natin kung ano ang hitsura nito sa Java code:

public static void main(String[] args) {
   int a = 10;

   System.out.println(" a = " + a + "; binary string: " + Integer.toBinaryString(a));
   System.out.println("~a = " + ~a + "; binary string: " + Integer.toBinaryString(~a));
}

Ngayon tingnan natin kung ano ang ipinapakita sa console: Sa unang linya nakuha namin ang halaga sa binary number system nang walang nangungunang mga zero. Kahit hindi namin sila nakikita, nandiyan sila. Ito ay pinatunayan ng pangalawang linya, kung saan ang lahat ng mga piraso ay binago sa mga reverse. Ito ang dahilan kung bakit nakikita natin ang napakaraming nangungunang mga yunit. Ito ang mga dating nangungunang zero na hindi pinansin ng compiler noong naka-print sa unang linya. Narito ang isang maliit na programa na nagpapakita rin ng mga nangungunang zero para sa kalinawan.

Bitwise AT operator

Nalalapat ang operator na ito sa dalawang numero. Nagsasagawa ito ng operasyon ANDsa pagitan ng mga bit ng bawat numero. Tingnan natin ang isang halimbawa: Ang operasyong ito ay ginagawa sa dalawang numero. Halimbawa sa Java code:

Bitwise O operator

O nalalapat sa dalawang numero. Nagsasagawa ito ng OR na operasyon sa pagitan ng mga bit ng bawat numero: Ngayon tingnan natin kung ano ang magiging hitsura nito sa IDEA:

Bitwise na operasyon, eksklusibo O (XOR)

Tingnan natin ang parehong halimbawa, ngunit may bagong operasyon: Halimbawang code:

Bitwise shift pakaliwa

Naaangkop ang operator na ito sa dalawang operand, iyon ay, sa operasyon x << y, ang mga bit ng numero xay maglilipat yng mga posisyon sa kaliwa. Ano ang ibig sabihin nito? Tingnan natin ang halimbawa ng operasyon. 10 << 1 Ang resulta ng operasyon ay ang numero 20 sa decimal system. Tulad ng makikita mo mula sa diagram sa itaas, ang lahat ng mga bit ay inilipat sa kaliwa ng 1. Sa panahon ng operasyong ito, ang halaga ng pinaka makabuluhang bit (ang pinakakaliwang bit) ay nawala. At ang hindi bababa sa makabuluhang bit (ang pinakakanang bit) ay puno ng zero. Ano ang masasabi mo sa operasyong ito?

1. Sa pamamagitan ng paglilipat ng mga bit ng isang numero Xsa pamamagitan Nng mga bit sa kaliwa, pinaparami namin ang numero Xsa pamamagitan ng 2 ^N .

   Narito ang isang halimbawa:

2. Ngunit! Ang tanda ng numero ay maaaring magbago kung ang bit na may halaga 1 ay nasa pinakakaliwang posisyon.

3. Kung lilipat ka pakaliwa nang walang katapusan, ang numero ay magiging 0. Ipakita natin ang mga puntos 2 at 3:

Bitwise shift pakanan

Nalalapat ang operator na ito sa dalawang operand. Yung. sa operasyon x >> y, ang mga bit ng numero xay maglilipat yng mga posisyon sa kanan. Tingnan natin ang isa pang halimbawa. Let us schematically pag - aralan ang operasyon 10 >> 1. Ilipat natin ang lahat ng bits ng numero 10 isang posisyon sa kanan: Sa panahon ng pagpapatakbo ng shift, nawawala ang mga tamang bit. Nawawala lang sila. Ang pinakakaliwang bit ay ang tanda ng numero (0 ay positibo, 1 ay negatibo). Samakatuwid, sa huling halaga ay inilalagay ito katulad ng sa orihinal na numero. Halimbawa na may negatibong numero: Nawala ang pinakakanang bit, at ang pinakakaliwang bit ay kinopya mula sa orihinal na numero, bilang isang honorary sign ng numero. Paano gawin ang lahat ng ito sa IDEA? Sa prinsipyo, walang kumplikado, kunin lamang ito at ilipat ito: Ngayon. Ano ang masasabi mo tungkol sa mga numerong inilipat sa kanan? Ang mga ito ay nahahati sa 2. Sa bawat oras na maglilipat kami ng isang bit sa kanan, hinahati namin ang orihinal na numero sa 2. Kung ang numero ay hindi mahahati ng 2, ang resulta ay ibibilog patungo sa minus na infinity (pababa). Ngunit ito ay gagana lamang kung ililipat natin ang mga bit sa eksaktong 1. At kung sa 2 bit, hatiin sa 4. Sa 3 bit, hatiin sa 8. Sa 4 bit, hatiin sa 16. Kita mo? Powers ng 2... Kapag inilipat namin ang isang numero Xsa Nkanan sa pamamagitan ng mga bit, hinahati namin ang numero Xsa pamamagitan ng 2 sa kapangyarihan ng 2 N. Pagpapakita:

public class BitOperationsDemo {

   public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {

        int shiftOperationResult = 2048 >> i;
        int devideOperationResult = 2048 / (int) Math.pow(2, i);


           System.out.println(shiftOperationResult + " - " + devideOperationResult);
    }

   }

}

Anong nangyayari dito?

1. Isang loop kung saan ang variable i ay dinaragdagan mula 1 hanggang 10.

2. Ang bawat pag-ulit ay kinakalkula namin ang 2 mga halaga:

• Isinulat namin sa variable shiftOperationResultang resulta ng paglilipat ng numero 2048 sa pamamagitan ng i bits sa kanan;

• devideOperationResultIsinulat namin ang resulta ng paghahati ng numerong 2048 ng 2 sa i power sa isang variable .

3. Ipinapakita namin ang dalawang nakuha na halaga nang pares.

Ang resulta ng pagsasagawa ng programa ay ang mga sumusunod: 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

Bitwise right shift na may zero padding

Habang ang isang normal na right shift ay nagpapanatili ng tanda ng numero (ang pinaka makabuluhang bit ay nagpapanatili ng halaga nito), ang isang zero-fill na right shift ay hindi. At ang pinaka makabuluhang bit ay puno ng zero. Tingnan natin kung ano ang hitsura nito:

Nangunguna sa mga operasyon sa Java

Tulad ng matematika, ang Java ay nangunguna sa mga operasyon. Ipinapakita ng talahanayan sa ibaba ang priyoridad (mula sa pinakamataas hanggang sa pinakamababa) ng mga operasyon na aming isinasaalang-alang.

Mga kapaki-pakinabang na halimbawa ng paggamit

Pagtukoy sa parity ng isang numero

Paghahanap ng maximum na elemento sa isang array

Upang mahanap ang pinakamababang elemento, baguhin lang ang tanda ng paghahambing sa tamang lugar.