- 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.
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:
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 x
at itinalaga ito ng isang halaga ng zero. Susunod, sa bawat linya ay nagtatalaga kami ng halaga x
sa kabuuan ng kasalukuyang halaga ng variable x
at 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:
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);
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:
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
).
!
- operator ng pagtanggi;&&
— lohikal AT operator (maikli);||
— lohikal O operator (maikli);&
— bitwise AT operator;|
— bitwise O operator;^
— bitwise eksklusibo O operator.
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 boolean
mga variable. Sa aming kaso, direktang inilapat namin ang mga ito sa mga halaga, ngunit maaari mo ring gamitin ang mga ito sa boolean
mga variable:
boolean
mga expression:
&&
, ||
) 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 x
tumagal 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.
&&
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:
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.
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 8 = 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 byte
memorya 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 byte
ay maaaring tumagal sa 256 iba't ibang mga halaga (128 negatibo, 127 positibo at 1 zero). Ang bawat halaga ng numero byte
ay may natatanging hanay ng walong bits. Ito ang kaso hindi lamang sa type byte
, ngunit sa lahat ng integral na uri. Ang uri byte
ay 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:
int
ang 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.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 natinNOT
, 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:
Bitwise AT operator
Nalalapat ang operator na ito sa dalawang numero. Nagsasagawa ito ng operasyonAND
sa 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 operasyonx << y
, ang mga bit ng numero x
ay maglilipat y
ng 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?
-
Sa pamamagitan ng paglilipat ng mga bit ng isang numero
X
sa pamamagitanN
ng mga bit sa kaliwa, pinaparami namin ang numeroX
sa pamamagitan ng 2 N .Narito ang isang halimbawa:
-
Ngunit! Ang tanda ng numero ay maaaring magbago kung ang bit na may halaga 1 ay nasa pinakakaliwang posisyon.
-
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 operasyonx >> y
, ang mga bit ng numero x
ay maglilipat y
ng 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:
X
sa N
kanan sa pamamagitan ng mga bit, hinahati namin ang numero X
sa 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?
-
Isang loop kung saan ang variable i ay dinaragdagan mula 1 hanggang 10.
- Ang bawat pag-ulit ay kinakalkula namin ang 2 mga halaga:
-
Isinulat namin sa variable
shiftOperationResult
ang resulta ng paglilipat ng numero 2048 sa pamamagitan ng i bits sa kanan; -
devideOperationResult
Isinulat namin ang resulta ng paghahati ng numerong 2048 ng 2 sa i power sa isang variable . -
Ipinapakita namin ang dalawang nakuha na halaga nang pares.
GO TO FULL VERSION