Mga Lohikal na Operator sa Java

• Mga Lohikal na Operator sa Java
• Logical negation operator!
• Lohikal na AT - &, pati na rin ang may kondisyong AT - &&
• Ang lohikal na OR ay ang operator |, pati na rin ang conditional na OR ay ang operator ||
• XOR - lohikal na eksklusibo O - operator ^
• Priyoridad ng mga lohikal na operasyon
• Mga kumplikadong lohikal na expression
• Mga operator ng bitwise (bitwise).
• Mga operator ng bitwise at, | at ^
• Karagdagang code
• Bitwise negation operator ~

Mga Lohikal na Operasyon sa Java

Ang mga lohikal na operasyon ay ginagawa gamit ang mga Boolean operator. Paumanhin ang tautolohiya, ngunit ito ay eksakto kung paano ang mga bagay. Ang mga pangunahing lohikal na operasyon (sa programming at matematika) ay maaaring ilapat sa mga lohikal na argumento (operand), at maaari ding gamitin upang bumuo ng mas kumplikadong mga expression, katulad ng mga operasyon ng aritmetika sa mga numero. Halimbawa ang expression:

(a | b) | (c < 100) & !(true) ^ (q == 5)

ay isang kumplikadong lohikal na expression na may apat na operand: (a | b), where аand bare type variables boolean (c < 100) (true) (q == 5) . Sa turn, ang isang simpleng logical expression (a | b)ay binubuo din ng dalawang operand na argumento. Ang lohikal na operand ay isang expression na masasabing totoo o mali, totoo o mali . Sa Java parlance, ang Boolean operand ay isang expression ng uri booleano Boolean, halimbawa:

• (2 < 1)— logical operand, mali ang halaga nito
• true- isang lohikal na operand na ang halaga ay malinaw na totoo
• boolean a- maaari ding maging isang lohikal na operand, tulad ng Boolean a
• int a = 2- ay hindi isang lohikal na operand , ito ay isang variable lamang ng uriint
• String a = "true"ay hindi rin isang lohikal na operand . Ito ay isang string na ang halaga ng teksto ay "true".

Ang mga sumusunod na lohikal na operasyon ay magagamit sa Java:

• Logical negation , na kilala rin NOTbilang inversion. Sa Java, ito ay ipinahiwatig ng " !" na simbolo bago ang operand. Nalalapat sa isang operand.
• Lohikal at , ito ay ANDisang pang-ugnay din. Ipinapahiwatig ng isang &simbolo na "" sa pagitan ng dalawang operand kung saan ito inilalapat.
• Lohikal o sa Java , ito rin ay - OR, ito rin ay disjunction. Sa Java, ito ay ipinahiwatig ng simbolong “ |” sa pagitan ng dalawang operand.
• Eksklusibo o , XOR, mahigpit na disjunction. Sa Java, ito ay ipinahiwatig ng simbolong “ ^” sa pagitan ng dalawang operand.
• Sa Java, kasama sa mga lohikal na operator ang conditional o , denoted bilang ||, pati na rin ang conditional at - &&.

Tandaan: din sa matematikal na lohika ay isinasaalang-alang nila ang katumbas na relasyon, sa madaling salita, pagkakapantay-pantay. Gayunpaman, sa Java, ang operator ng pagkakapantay-pantay==ay hindi itinuturing na isang lohikal na operator. Pansin! Sa Java, ang mga lohikal na operator&,|at^nalalapat din sa mga integer. Sa kasong ito, gumagana ang mga ito nang bahagyang naiiba at tinatawag na bitwise (o bitwise) na mga lohikal na operator. Tungkol sa kanila - sa dulo ng artikulo. Tingnan natin ang isang talahanayan na may maikling paglalarawan ng bawat isa sa mga lohikal na operator ng Java, at sa ibaba ay ilalarawan namin ang mga ito nang mas detalyado at magbibigay ng mga halimbawa ng code.

Logical negation operator!

Ang operator na ito ay unary, ibig sabihin, nalalapat ito sa isang Boolean expression o operand. Napakasimpleng unawain, tulad ng anumang negasyon: binabago lang ng operator ang kahulugan ng expression sa kabaligtaran nito. Talahanayan ng katotohanan o mga resulta ng pagsasagawa ng negation operation: Halimbawa. Logical negation na operasyon

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       System.out.println(!a); // here our boolean expression reverses its value
       System.out.println(!false); // non-false expression, as you might guess, will be equal to... what?
       System.out.println(!(2 < 5)); // expression (2 < 5) is true, so its negation is false

   }
}

Ang output ng programa ay ang mga sumusunod:

false
true
false

Lohikal na AT - &, pati na rin ang may kondisyong AT - &&

Ang lohikal na AT o conjunction ay inilalapat sa dalawang expression, at ang resulta nito ay magiging totoo lamang kung ang parehong mga operand ay totoo. Iyon ay, kung ang isa sa amga o operand bay false , ang expression a & bay magiging false anuman ang halaga ng pangalawang operator. Kung iniisip mo na ang totoo ay ang numero 1 at ang mali ay 0, kung gayon ang operator &ay gumagana nang eksakto katulad ng regular na pagpaparami. Samakatuwid, ang lohikal na AT ay madalas na tinatawag na "lohikal na pagpaparami." At, sa pamamagitan ng paraan, ang katotohanang ito ay nakakatulong upang mabilis na matandaan ang pagpapatakbo ng operator &at hindi malito ito sa lohikal o operator |. Talahanayan ng katotohanan AT, ito rin ay resulta ng trabaho ng operator& Lohikal na AT, ito rin ay isang pang-ugnay, mga halimbawa:

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       boolean c = true;
       System.out.println(a & b); // if we multiply true by false, we will definitely get false
       System.out.println(a & c); // true to true will be true
       System.out.println(false & (2 > 5));
 System.out.println((2 < 5) & false);
 // regardless of the truthfulness of the expression in brackets, in which case we have to be content with false
   }
}

Resulta ng programa:

false
true
false
false

Kung minsan ang operator &&ay tinatawag na "maikli AT". Gumagawa ito ng parehong resulta kapag nagtatrabaho sa mga lohikal na operand bilang operator &. Gayunpaman, may pagkakaiba sa kanyang trabaho mismo. Kaya, napansin mo na kung a & bang operand sa expression ( ) aay false , kung gayon walang saysay na suriin ang halaga ng operand b: ang resulta ng operasyon ay tiyak na magiging false . Kaya kung hindi natin kailangan ang halaga ng pangalawang operand, ang paggamit nito ay &&binabawasan natin ang bilang ng mga kalkulasyon sa programa. Kung papalitan natin ang lahat ng mga operator sa halimbawa &ng &&, ang resulta ay magiging eksaktong pareho, ngunit ang programa mismo ay tatakbo nang kaunti nang mas mabilis (bagaman hindi natin ito mapapansin, dahil ang pinag-uusapan natin ay tungkol sa mili-micro... sa madaling salita , napakaliit na mga yunit ng oras).

Ang lohikal na OR ay ang operator |, pati na rin ang conditional na OR ay ang operator ||

Ang OR operator sa Java ay kinakatawan ng simbolo |. Ang isang lohikal na OR o disjunction ay inilalapat sa dalawang expression, at ang resulta nito ay magiging mali kung at kung ang parehong mga operand ay mali. Dito namin sa ilang mga lawak obserbahan ang parehong larawan tulad ng sa kaso ng operator &, ngunit eksakto ang kabaligtaran. Iyon ay, kung hindi bababa sa isang operand ay true , kung gayon ang expression a | bay garantisadong totoo anuman ang halaga ng pangalawang operator. Kung &ito ay kumikilos tulad ng lohikal na pagpaparami, kung gayon ang OR ay lohikal na karagdagan, kung akala mo na totoo ay 1 at mali ay 0. Tandaan lamang na ang lohikal na karagdagan ay gumagana nang iba kaysa sa normal na karagdagan. Ang 1 + 1 sa kasong ito ay katumbas ng hindi 2, ngunit sa 1 (ang numero 2 ay hindi umiiral sa sistemang ito). Kung minsan ang disjunction ay nauunawaan bilang ang maximum ng 0 at 1, at sa kasong ito, kung ang hindi bababa sa isang operand ay katumbas ng 1 ( true ), makakakuha tayo ng eksaktong true . O talahanayan ng katotohanan, na kilala rin bilang resulta ng operator |: Lohikal na OR, na kilala rin bilang disjunction, halimbawa:

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       boolean c = true;
       System.out.println(!a | b); // Compose the use of two logical operators: a == true, so !a, as we already know, is false.
       System.out.println(a | c);
       System.out.println((2 < 5) | false); // expression (2 < 5) is true, which means that for any second operand we get a true result
       System.out.println((2 > 5) | true);

   }
}

Resulta:

false
true
true
true

Kung gagamitin natin ang conditional OR operator - ||sa halip na |, makakakuha tayo ng eksaktong kaparehong resulta, ngunit, tulad ng sa conditional AND &&, ito ay kikilos nang matipid: kung tayo ay "matatakbuhin" ang unang operand na katumbas ng true , ang halaga ng ang pangalawang operand ay hindi nasuri, ngunit kaagad ang resulta ay totoo .

XOR Java - lohikal na eksklusibo O - operator ^

XOR, modulo 2 karagdagan, lohikal na XOR, lohikal na pagbabawas, mahigpit na disjunction, bitwise complement... ang operator ^ay maraming pangalan sa Boolean algebra. Magiging totoo ang resulta ng paglalapat ng operator na ito sa dalawang operand kung magkaiba ang mga operand at mali kung pareho ang mga operand. Samakatuwid, ito ay maginhawa upang ihambing ito sa pagbabawas ng mga zero ( false ) at ones ( true ). Talahanayan ng katotohanan XOR, na kilala rin bilang resulta ng operator ^: Halimbawa:

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       boolean c = true;
       System.out.println(!a ^ b); // Compose the use of two logical operators: a == true, so !a, as we already know, is false.
       System.out.println(a ^ c);
       System.out.println((2 < 5) ^ false);
       System.out.println((2 > 5) ^ true);
   }
}

Resulta:

false
false
true
true

Priyoridad ng mga lohikal na operasyon

Tulad ng sa matematika, sa programming operator ay may isang tiyak na execution order kapag sila ay lumitaw sa parehong expression. Ang mga unary operator ay may mga pakinabang kaysa sa mga binary, at multiplikasyon (kahit na lohikal) kaysa sa karagdagan. Nai-rank namin ang mga logical operator na mas mataas sa listahan, mas mataas ang kanilang priyoridad:

1. !
2. &
3. ^
4. |
5. &&
6. ||

Tingnan natin ang mga halimbawa. Ang pang-ugnay at disjunction ( &at |) ay may iba't ibang nauuna:

public class Solution {
   public static void main(String[] args) {
       boolean a = true, b = true, c = false;
       System.out.println(a | b & c);
}

Kung magpapatuloy tayo mula kaliwa hanggang kanan, iyon ay, ilapat muna ang operator |at pagkatapos - &, makukuha natin ang value na false . Ngunit sa katunayan, kung patakbuhin mo ang program na ito, makatitiyak ka na ang output ay magiging totoo , dahil ang lohikal na AND operator &ay magkakaroon ng mas mataas na priyoridad kaysa sa lohikal O operator |. Upang maiwasan ang pagkalito, kailangan mong tandaan na kung ano &ang kumikilos tulad ng multiplikasyon at |kung ano ang kumikilos tulad ng karagdagan. Maaari mong baguhin ang priority order. Gumamit lamang ng mga bracket, tulad ng sa matematika sa paaralan. Baguhin natin ng kaunti ang ating halimbawang code:

public class Solution {
   public static void main(String[] args) {
       boolean a = true, b = true, c = false;
       System.out.println((a|b)&c);
}

ano na? Una ay gumagamit kami ng lohikal na pagdaragdag sa mga bracket, at pagkatapos ay pagpaparami. Magiging mali ang resulta .

Mga kumplikadong lohikal na expression

Siyempre, maaari nating pagsamahin ang mga Boolean na expression at operator. Tandaan natin ang expression mula sa simula ng artikulo:

(a | b) | (c < 100) & !(true) ^ (q == 5)

Ngayon ay hindi na ito nakakatakot. Sumulat tayo ng isang programa na nagpapakita ng halaga nito, na dati nang natukoy ang mga halaga ng a, b, сat q. Halimbawa ng pagkalkula ng halaga ng isang kumplikadong Boolean expression

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       int c = 25;
       int q = 2;
       System.out.println((a|b) | (c < 100) & !(true)^(q == 5));
   }
}

Tandaan:qang aming variable ay uri int, ngunit q == 5ito ay isang Boolean na expression, at ito ay katumbas ng false , dahil sa itaas ay sinimulan namin qang numero 2. Ang parehong ay sa variable c. Ang numerong ito ay katumbas ng 25, ngunit (c <100) ay isang Boolean na expression na katumbas ng true . Ang resulta ng programang ito:

true

Ang mga kumplikadong Boolean na expression ay maaaring gamitin upang subukan ang napaka-kumplikado at branchy na mga kondisyon, ngunit hindi sila dapat gamitin nang labis: ginagawa nilang mahirap basahin ang code.

Mga operator ng bitwise (bitwise).

Sa simula ng artikulo, binanggit namin na ang mga operator &, |at ^maaaring gamitin kaugnay ng mga uri ng Java integer. Sa kasong ito sila ay bitwise operator. Tinatawag din silang bitwise, dahil ang isang digit ay isang bit, at ang mga operasyong ito ay partikular na gumagana sa mga bit. Siyempre, gumagana ang mga ito nang medyo naiiba kaysa sa mga lohikal na operator, at upang maunawaan nang eksakto kung paano, kailangan mong malaman kung ano ang isang binary number system. Kung wala kang alam tungkol dito o ganap na nakalimutan, iminumungkahi namin na basahin mo muna ang artikulong Java: bits and bytes , at ipaalala sa iba na sa binary number system mayroon lamang dalawang digit - 0 at 1, at lahat ng data sa computer ay tiyak na kinakatawan sa paggamit ng mga kondisyon na zero at isa. Anuman sa mga numerong nakasanayan na natin (decimal; para sa kanila ay mayroong 10 magkakaibang digit mula 0 hanggang 9, kung saan isinusulat natin ang anumang mga numero) ay maaaring katawanin sa binary number system. Maaari mong i-convert ang isang decimal na numero sa binary gamit ang sequential division sa isang column gamit ang number system base (2). Ang mga natitira sa dibisyon sa bawat hakbang, na nakasulat sa reverse order, ay magbibigay sa amin ng nais na binary number. Narito, halimbawa, ang conversion ng decimal na numero 103 sa binary na representasyon: Bilang karagdagan sa &, |at ^gumagamit din ang Java ng mga bitwise na operator:

• ~ bitwise negation operator
• >>bitwise shift pakanan
• >>>unsigned bitwise right shift
• <<bitwise shift pakaliwa

Para sa mga nagsisimula, ang mga bitwise operator ay tila napakalito at artipisyal. Kadalasan ay hindi nila naiintindihan kung ano ang kailangan nila, maliban sa paglutas ng mga problema sa edukasyon. Sa katunayan, magagamit ang mga ito sa pinakamababa upang ayusin ang mahusay na paghahati at pagpaparami, at ginagamit ito ng mga propesyonal para sa pag-encode/pag-decode, pag-encrypt, at pagbuo ng mga random na numero.

Mga operator ng bitwise at, | at ^

Tingnan natin ang isang halimbawa kung paano gumagana ang mga operator na ito. Sabihin nating mayroon tayong dalawang integer:

int a = 25;
int b = 112; 

Kailangan nating maglapat ng tatlong operasyon sa kanila &, |at ^ipakita ang resulta sa screen. Narito ang code ng programa:

public class Solution {
   public static void main(String[] args) {

       int a = 25;
       int b = 112;

       int res1 = a & b;
       int res2 = a | b;
       int res3 = a ^ b;

       System.out.println("a & b = " + res1);
       System.out.println("a | b = " + res2);
       System.out.println("a ^ b = " + res3);

   }
}

Ang resulta ng programa ay ang mga sumusunod:

a & b = 16
a | b = 121
a ^ b = 105

Kung hindi mo maintindihan kung ano ang nangyayari, ang resulta ay mukhang napaka, napaka misteryoso. Sa katunayan, ang lahat ay mas simple kaysa sa tila. Ang mga bitwise operator ay "nakikita" ang mga numero ng operand sa kanilang binary form. At pagkatapos ay inilalapat nila ang mga lohikal na operator &, |o ^sa kaukulang mga digit (bit) ng parehong mga numero. Kaya, para &sa huling bit ng binary na representasyon ng numero 25 ay lohikal na nagdaragdag hanggang sa huling bit ng binary na representasyon ng numero 112, ang penultimate bit na may penultimate na isa, at iba pa: Ang parehong lohika ay maaaring masubaybayan sa kaso ng |at ^.

Bit shift pakaliwa o pakanan

Mayroong ilang mga bit shift operator sa Java. Ang pinakakaraniwang ginagamit na mga operator <<ay at >>. Inilipat nila ang binary na representasyon ng isang numero sa kaliwa o kanan, ayon sa pagkakabanggit, at sa kaso ng paglilipat sa kanan, habang pinapanatili ang sign (ipapaliwanag namin kung ano ang ibig sabihin ng pagpreserba sa sign sa ibaba). May isa pang right shift operator >>>. Ginagawa nito ang parehong bagay ngunit >>hindi nai-save ang tanda. Kaya, tingnan natin ang kanilang trabaho gamit ang isang halimbawa. int a = 13 a << 1inililipat ang lahat ng mga bit ng binary na representasyon ng numero a sa kaliwa ng 1 bit. Upang pasimplehin, isipin natin ang numerong 13 sa binary bilang 0000 1101. Sa katunayan, ganito ang hitsura ng numerong ito: 00000000 00000000 00000000 00001101, dahil ang Java ay intnaglalaan ng 4 na byte o 32 bits para sa mga numero. Gayunpaman, hindi ito gumaganap ng isang papel sa halimbawa, kaya sa halimbawang ito ay isasaalang-alang namin ang aming numero bilang one-byte. Ang bit na nabakante sa kanan ay puno ng mga zero. Bilang resulta ng operasyong ito, nakuha namin ang numero 26. a << 2Inililipat nito ang lahat ng mga bit ng binary na representasyon ng numero asa kaliwa ng 2 bits, at ang dalawang bit na nabakante sa kanan ay puno ng mga zero. Bilang resulta, makukuha natin ang numerong 52. a << 3Ang resulta ay magiging 104... Pansinin ang pattern? Ang bitwise na paglilipat asa kaliwa ng n mga posisyon ay gumagana tulad ng pagpaparami ng isang numero asa pamamagitan ng 2 sa kapangyarihan ng n. Ang parehong naaangkop sa mga negatibong numero. -13 << 3Ibibigay nito ang resulta -104. a >> ninililipat ang binary na representasyon ng isang numero n mga posisyon sa kanan. Halimbawa, 13 >> 1 Binabago ang numerong 1101 sa numerong 0110, iyon ay, 6. At 13 >> 2ang resulta ay magiging 3. Iyon ay, sa esensya, narito, hinahati natin ang numero sa pamamagitan ng 2 sa kapangyarihan ng n, kung saan ang n ay ang bilang ng mga paglilipat. sa kanan, ngunit may isang caveat: kung kakaiba ang numero , sa panahon ng operasyong ito, tila nire-reset namin ang huling bit ng numero. Ngunit sa mga negatibo ang sitwasyon ay medyo naiiba. Sabihin nating, subukang suriin kung ano ang gagawin ng program kung hihilingin mo itong magsagawa ng operasyon -13 >> 1. Makikita mo ang numero -7, hindi -6, gaya ng iniisip mo. Nangyayari ito dahil sa paraan ng pag-iimbak ng mga negatibong numero sa Java at iba pang mga programming language. Ang mga ito ay naka-imbak sa tinatawag na complementary code. Sa kasong ito, ang pinaka makabuluhang digit (ang nasa kaliwa) ay ibinibigay sa sign. Sa kaso ng isang negatibong numero, ang pinaka makabuluhang digit ay 1.

Karagdagang code

Isaalang-alang natin ang numero int a = 13. Kung sa programa ay nai-print mo ang binary na representasyon nito sa console gamit ang command System.out.println(Integer.toBinaryString(a));, makakakuha tayo ng 1101. Sa katunayan, ito ay isang shorthand notation, dahil ang uri ng numero intay tumatagal ng 4 bytes sa memorya, kaya ang computer ay "mas nakikita" ito. ganito:

00000000 00000000 00000000 00001101

Ang pinakamahalagang digit ay zero, na nangangahulugang mayroon tayong positibong numero. Upang i-convert sa karagdagang code:

1. Isinulat namin ang numero -13 sa tinatawag na "direktang code". Upang gawin ito, baguhin ang pinaka makabuluhang digit ng numero sa 1.
   Resulta ng aksyon:

   
   10000000 0000000 0000000 00001101

2. Susunod, binabaligtad namin ang lahat ng mga bit (binabago namin ang 0 hanggang 1, at 1 hanggang 0) maliban sa sign bit. Sa katunayan, binago na natin ito.
   Resulta ng aksyon:

   
   11111111 11111111 11111111 11110010

   (oo, maaaring pagsamahin ang mga hakbang 1 at 2, ngunit mas mabuting isipin ito sa ganoong paraan)

3. Magdagdag ng 1 sa resultang numero.
   Resulta ng aksyon:

   
   11111111 11111111 11111111 11110011

Ang resultang binary number ay -13, nakasulat sa complement code ng dalawa, at ang bit shift (at iba pang mga operasyon) ay partikular na ilalapat dito. Ito ay lamang na ang pagkakaiba sa lohika ng operasyon ay hindi kapansin-pansin sa lahat ng mga operasyon. Sabihin nating, para sa parehong paglipat sa kaliwa, ang pagkakaiba ay hindi napapansin; maaari tayong magtrabaho sa mga negatibong numero sa parehong paraan tulad ng sa mga positibong numero. Ngayon lumipat tayo sa kanan -13 >> 1. Dahil >>pinapanatili ng aming operator ang pag-sign, sa operasyong ito ang lahat ng mga bit na napalaya sa kaliwa ay napuno hindi ng mga zero, ngunit ng mga isa. Kaya, ang paglilipat ng numero

11111111 11111111 11111111 11110011

isang bit sa kanan, na nagreresulta sa sumusunod na pagkakasunud-sunod ng mga bit:

11111111 11111111 11111111 11111001

Kung i-convert natin ang numerong ito sa direktang code (iyon ay, ibawas muna ang 1, pagkatapos ay baligtarin ang lahat ng mga bit maliban sa una) makuha natin ang numero:

10000000 00000000 00000000 00000111

o -7. Ngayong naunawaan na natin ang operator ng right shift na nagpapanatili ng sign, magiging malinaw kung paano ito naiiba sa operator >>>. a >>> n— ang operasyong ito ay isang unsigned shift, iyon ay, inililipat nito ang binary na representasyon ng isang numero asa kanan sa pamamagitan ng n bits, ngunit pinupunan ang n bits na nabakante sa kaliwa hindi ng mga, tulad ng operator >>, ngunit may mga zero. Gawin natin ang operasyon -13 >>> 1. Mayroon na tayong numero -13sa dalawang's complement:

11111111 11111111 11111111 11110011

Sa pamamagitan ng paglilipat sa kanan ng 1 bit at pagpuno sa libreng bit ng zero, nakukuha namin ang sumusunod na numero:

01111111 11111111 11111111 11111001

Ano ang nagbibigay ng numero sa decimal notation 2147483641.

Bitwise negation operator ~

Ang unary operator na ito ay gumagana nang napakasimple: binabaligtad nito ang bawat bit ng binary na representasyon ng isang integer. Kunin natin ang numero -13:

11111111 11111111 11111111 11110011

Ang pagpapatakbo ng bitwise negation ~13ay mababaligtad lamang ang halaga ng bawat bit. Bilang resulta, nakukuha namin ang:

00000000 00000000 00000000 00001100

O 12sa decimal form.

Maikling konklusyon

• Nalalapat ang lahat ng lohikal na operator sa mga expression ng Boolean, iyon ay, ang mga masasabing totoo o mali .
• Kung ang mga operator &, |o ^inilapat sa mga numero, hindi na natin pinag-uusapan ang mga lohikal na operasyon, ngunit tungkol sa mga bitwise. Iyon ay, ang parehong mga numero ay na-convert sa binary system at ang mga operasyon ng lohikal na karagdagan, multiplikasyon o pagbabawas ay inilalapat sa mga numerong ito nang paunti-unti.
• Sa mathematical logic, ang mga operator &at |tumutugma sa conjunction at disjunction.
• Ang lohikal na AT ay katulad ng pagpaparami ng 1 ( true ) at 0 ( false ).
• Ang lohikal na OR ay katulad ng paghahanap ng maximum sa 1 ( true ) at 0 ( false ).
• Para sa bitwise negation ng isang integer a, ginagamit ang operator ~a.
• Upang lohikal na tanggihan ang isang Boolean expression a, gamitin ang operator !a.
• Ang mga negatibong numero ay iniimbak at pinoproseso sa complement code ng dalawa.
• Ang isang bitwise na paglipat sa kanan ay maaaring >>mapanatili o hindi ang sign ( >>>).