Course జావా మల్టీథ్రెడింగ్ - Lecture: ఆపరేటర్ ప్రాధాన్యత

"హాయ్, బిలాబో!"

"బిలాబో తన స్నేహితుడిని పలకరించడం సంతోషంగా ఉంది!"

"ఈ రోజు బిలాబో మీకు ఆపరేటర్ ప్రాధాన్యత గురించి చెబుతాడు. అయితే ముందుగా అతను మీకు ఆపరేటర్ల గురించి చెబుతాడు."

"ఈ ఆపరేటర్ల గురించి మీరు మాట్లాడుతున్నారు?"

"వాస్తవానికి, మీరు వారితో ఇప్పటికే సుపరిచితులు. వారిని ఆపరేటర్లు అని పిలుస్తారని మీకు తెలియకపోవచ్చు."

"ఉదాహరణకు, మనకు c = a + b అనే వ్యక్తీకరణ ఉందని చెప్పండి; "

"దీనికి ఇద్దరు ఆపరేటర్లు ఉన్నారు: ఒక అదనపు ఆపరేటర్ మరియు ఒక అసైన్‌మెంట్ ఆపరేటర్."

"మరో మాటలో చెప్పాలంటే, ఆపరేటర్లు కేవలం గణిత సంకేతాలు మాత్రమేనా? గుణకారం, భాగహారం మరియు కూడిక వంటివి?"

"అవును నిజమే. అయినా తేడాలున్నాయి."

"నేను మీ కోసం ఆపరేటర్‌లను నిర్వచించను: నిర్వచనం మిమ్మల్ని తెలివిగా మార్చదు. వాటిని చర్యలో చూడటం మంచిది. ఆపరేటర్‌లను అనేక సమూహాలుగా విభజించవచ్చు, వాటిని మేము ఇప్పుడు పరిశీలిస్తాము."

1) " గణిత ఆపరేటర్లు "

చిహ్నం	ఉదాహరణ	పేరు	వివరణ (ఇది ఏమి చేస్తుంది)
`+`	`a + b`	అదనపు ఆపరేటర్	అదనపు ఆపరేటర్.
`-`	`c - d`	తీసివేత ఆపరేటర్	మొదటి సంఖ్య నుండి రెండవ సంఖ్యను తీసివేస్తుంది.
`*`	`a * t`	గుణకార ఆపరేటర్	రెండు సంఖ్యలను గుణిస్తుంది.
`/`	`a / b`	డివిజన్ ఆపరేటర్	మొదటి సంఖ్యను రెండవ సంఖ్యతో భాగిస్తుంది.
`%`	`c % d`	మొదటి సంఖ్యను రెండవ సంఖ్యతో భాగిస్తుంది.	మొదటి సంఖ్యను రెండవ సంఖ్యతో భాగించిన తర్వాత మిగిలిన మొత్తాన్ని గణిస్తుంది.
`-`	`-a`	యునారీ మైనస్	వేరియబుల్ యొక్క చిహ్నాన్ని దాని వ్యతిరేకతకు మారుస్తుంది. ప్లస్ నుండి మైనస్, మరియు మైనస్ నుండి ప్లస్.
`+`	`+a`	యునరీ ప్లస్	దేనినీ మార్చదు. ఇది unary మైనస్ ఆపరేటర్‌ను అభినందించడానికి జోడించబడింది. ఇది కేవలం లుక్స్ కోసమే.

"నేను వీటిని పాఠశాల నుండి గుర్తించాను. నా ఫర్మ్‌వేర్ పాఠశాల కోర్సులను కలిగి ఉంటుంది."

"అయితే, ఆ శాతం గుర్తుతో ఏముంది, ఒక విధమైన తాంత్రికుడు?"

"ఇది " విభజన తర్వాత మిగిలినది " ఆపరేటర్. 11ని 5తో భాగిస్తే, మనకు 2 మరియు మిగిలిన 1 వస్తుంది. ఈ 1ని 11 % 5 రాయడం ద్వారా పొందవచ్చు;"

"మీరు జావాలో పూర్ణాంకాలను విభజించినప్పుడు, ఫలితం కూడా పూర్ణాంకం. విభజన ఆపరేషన్ నుండి మిగిలినవి విస్మరించబడతాయి. మనం 8ని 5తో భాగిస్తే, మనకు 1 వస్తుంది."

వ్యక్తీకరణ	ఫలితం
`19 / 10`	1	మనం 19ని 10తో భాగిస్తే, ఫలితం 1 మరియు మిగిలిన 9.
`19 % 10`	9	మనం 19ని 10తో భాగిస్తే, ఫలితం 1 మరియు మిగిలిన 9 .
`2 / 5`	0	మనం 2ని 5తో భాగిస్తే, ఫలితం 2తో పాటు 0 అవుతుంది.
`16 % 2`	0	మనం 16ని 2తో భాగిస్తే, ఫలితం 8 మరియు మిగిలిన 0 .

"అయితే ప్రపంచంలో మనకు మిగిలినవి దేనికి కావాలి?"

"పూర్ణాంకం సమానంగా ఉందో లేదో మీరు తనిఖీ చేయాలి. అప్పుడు మీరు వ్రాయవచ్చు:"

if (a % 2 == 0)

"మరియు మీరు b బేసి కాదా అని తనిఖీ చేయవలసి వస్తే, మీరు వ్రాయవచ్చు:"

if (b % 2 == 1)

"లేదా d 3 ద్వారా భాగించబడుతుందో లేదో తనిఖీ చేయడానికి:"

if (d % 3 == 0)

"ఆసక్తికరంగా ఉంది. నేను దానిని గుర్తుంచుకుంటాను."

2) " పోలిక ఆపరేటర్లు "

చిహ్నం	ఉదాహరణ	పేరు	వివరణ (ఇది ఏమి చేస్తుంది)
`<`	`a < b`	కంటే తక్కువ	a b కంటే తక్కువగా ఉందో లేదో తనిఖీ చేస్తుంది.
`<=`	`c <= d`	దీని కంటే తక్కువ లేదా సమానం	c అనేది d కంటే తక్కువ లేదా సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది.
`>`	`a > b`	అంతకన్నా ఎక్కువ	a b కంటే ఎక్కువగా ఉందో లేదో తనిఖీ చేస్తుంది.
`>=`	`c >= d`	దీని కంటే ఎక్కువ లేదా సమానం	c అనేది d కంటే ఎక్కువ లేదా సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది.
`==`	`i == j`	సమానం	i jకి సమానం కాదా అని తనిఖీ చేస్తుంది.
`!=`	`a != 0`	సమానం కాదు	a సున్నాకి సమానం కాదా అని తనిఖీ చేస్తుంది.

"నేను ఇప్పటికే ఇవన్నీ ఉపయోగించాను."

"మరియు ఈ ఆపరేటర్లు మరియు గణిత ఆపరేటర్ల మధ్య ప్రధాన తేడా ఏమిటి?"

"మనం రెండు సంఖ్యలను జోడిస్తే, మనకు ఒక సంఖ్య వస్తుంది; కానీ, మనం రెండు సంఖ్యలను పోల్చినట్లయితే, మనకు నిజం లేదా తప్పు అవుతుంది."

"అది నిజం. పోలిక యొక్క ఫలితం " తార్కిక విలువ " విలువ, ఇది మీకు తెలిసినట్లుగా, బూలియన్ రకం ద్వారా సూచించబడుతుంది. రెండు అవకాశాలు ఉన్నాయి: ఒప్పు లేదా తప్పు.

"అవును, అంతా క్లియర్‌గా ఉంది. అది నాకు ముందే తెలుసు."

3) " లాజికల్ ఆపరేటర్లు "

చిహ్నం	ఉదాహరణ	పేరు	వివరణ (ఇది ఏమి చేస్తుంది)
`&&`	`a && b`	మరియు	a మరియు b రెండూ నిజం అయినప్పుడు మాత్రమే వ్యక్తీకరణ యొక్క ఫలితం నిజం అవుతుంది.
`\|\|`	`c \|\| d`	లేదా	వ్యక్తీకరణ యొక్క ఫలితం a లేదా b నిజమైతే నిజం. రెండూ లేదా కనీసం ఒకటి.
`!`	`!a`	కాదు	వ్యక్తీకరణ యొక్క ఫలితం a తప్పు అయితే మాత్రమే నిజం.

"లాజికల్ ఆపరేటర్లు బూలియన్ వేరియబుల్స్ లేదా ఎక్స్‌ప్రెషన్‌లతో మాత్రమే ఉపయోగించబడతాయి."

ఉదాహరణ	వివరణ
`boolean a = true;` `boolean b = true;if (a && b)`	రెండు విలువలు నిజమైతే షరతు నిజమైతే , మరో మాటలో చెప్పాలంటే, a మరియు b రెండూ నిజమైతే, ఫలితం నిజం .
`boolean a = true;` `boolean b = false;if (a \|\| b)`	కనీసం ఒక విలువ నిజమైతే షరతు నిజమైతే , మరో మాటలో చెప్పాలంటే, a లేదా b నిజం అయితే, ఫలితం నిజం .
`boolean b = false;` `if (!b)`	b నిజం కాకపోతే if షరతు నిజం. మరో మాటలో చెప్పాలంటే, b తప్పు అయితే , ఫలితం నిజం .
`int a = 2, b = 3, c = 4;` `if (a < b && a < c)` `if ((a < b) && (a < c))`	a అనేది b కంటే తక్కువ మరియు a c కంటే తక్కువగా ఉంటే, వ్యక్తీకరణ యొక్క ఫలితం నిజం. a, b మరియు c అనేవి పూర్ణాంకాలు, కానీ పూర్ణాంకాలను పోల్చడం వల్ల వచ్చే ఫలితం తార్కిక విలువ (నిజం, తప్పు), అంటే మనం లాజికల్ ఆపరేటర్‌లను ఉపయోగించవచ్చు.

"ఇవన్నీ నాకు ముందే తెలుసు."

"నిజమేనా? అప్పుడు కొనసాగిద్దాం."

4) " బిట్‌వైస్ ఆపరేటర్లు "

చిహ్నం	ఉదాహరణ	పేరు	వివరణ (ఇది ఏమి చేస్తుంది)
`&`	`a & b`	మరియు	బిట్‌వైస్ మరియు
`\|`	`c \| d`	లేదా	బిట్‌వైస్ OR
`~`	`~a`	కాదు	బిట్‌వైస్ కాదు
`^`	`a ^ b`	XOR	బిట్‌వైస్ "ఎక్స్‌క్లూజివ్ లేదా"

" బిట్‌వైజ్ ఆపరేటర్‌లు పూర్ణాంకాలపై బిట్-బై-బిట్ కార్యకలాపాలను నిర్వహిస్తారు."

"అదేమిటి?"

"ప్రతి సంఖ్య బిట్‌ల సమితిగా సూచించబడుతుంది, ఆపై ఫలితం క్రింది విధంగా లెక్కించబడుతుంది:"

"రెండు సంఖ్యల మొదటి బిట్ 1 అయితే, ఫలితం యొక్క మొదటి బిట్ 1 అవుతుంది."

"రెండు సంఖ్యల రెండవ బిట్ 1 అయితే, ఫలితం యొక్క రెండవ బిట్ 1 అవుతుంది. మరియు అందువలన న."

"బిట్‌వైజ్ ఆపరేటర్‌లందరికీ ఇది నిజమేనా?"

"ఇది దాని కంటే చాలా సులభం. ఒక బిట్ 0 మరియు 1 అనే రెండు విలువలను మాత్రమే కలిగి ఉంటుంది, సరియైనదా?"

"సరియైనది."

"తర్వాత 1ని నిజం మరియు 0 తప్పుగా భావించండి. వ్యక్తిగత బిట్‌లపై చేసే కార్యకలాపాలు దాదాపు లాజికల్ ఆపరేషన్‌లకు సమానంగా ఉంటాయి:"

తార్కిక వ్యక్తీకరణ	బిట్‌వైస్ వ్యక్తీకరణ
నిజం && నిజం == నిజం	`1&1 == 1`
నిజం && తప్పుడు == తప్పు	`1&0 == 0`
నిజం \|\| నిజం == నిజం	`1\|1 == 1`
నిజం \|\| తప్పు == నిజం	`1\|0 == 1`
తప్పుడు \|\| false = తప్పు	`0\|0 == 0`
!తప్పు == నిజం	`~0 == 1`
!నిజం == తప్పు	`~1 == 0`

"ఓహ్! అది చాలా సులభం."

"అవును, బిట్‌వైస్ కార్యకలాపాలు రెండు సంఖ్యల నుండి సంబంధిత బిట్‌లను ఉపయోగిస్తాయని మర్చిపోవద్దు."

"అవును, నాకు గుర్తుంది: ఒక సంఖ్య యొక్క మొదటి బిట్ రెండవ మొదటి బిట్‌తో జత చేయబడింది మరియు ఫలితం మొదటి బిట్‌కు కూడా వ్రాయబడుతుంది. మరియు మిగిలిన బిట్‌లకు కూడా అదే జరుగుతుంది."

"అది సరే. నీకు ఇంకేమైనా ప్రశ్నలు ఉన్నాయా?"

"XOR మరియు 'ఎక్స్‌క్లూజివ్ లేదా'తో ఏముంది?"

"ఇది కేక్ ముక్క: విలువలు భిన్నంగా ఉన్నప్పుడు, ఇది నిజం; అవి ఒకేలా ఉన్నప్పుడు, అది తప్పు."

తార్కిక వ్యక్తీకరణ	బిట్‌వైస్ వ్యక్తీకరణ
నిజమైన XOR నిజం == తప్పు	`1 ^ 1 == 0`
తప్పు XOR తప్పుడు == తప్పు	`0 ^ 0 == 0`
నిజమైన XOR తప్పుడు == నిజం	`1 ^ 0 == 1`
తప్పు XOR నిజం == నిజం	`0 ^ 1 == 1`

బిట్‌వైస్ ఆపరేషన్‌ల యొక్క మరికొన్ని ఉదాహరణలు ఇక్కడ ఉన్నాయి:

ఉదాహరణ	సంఖ్యలు బిట్‌లుగా	బిట్స్‌గా ఫలితం	ఫలితం
`5 & 3`	0000010 1 & 0000001 1	0000000 1	1
`7 & 2`	000001 1 1 & 000000 1 0	00000010	2
`5 \| 9`	00000 1 0 1 \| 0000 1 00 1	00001101	13
`5 ^ 9`	00000 101 ^ 00001001	0000 1100	12
`~9`	~ 00001001	11110110	246

"ధన్యవాదాలు, బిలాబో. ఇప్పుడు నాకు తెలుసు."

"ఇంకో బిట్‌వైస్ ఆపరేటర్ల సమూహం ఉంది, షిఫ్ట్ ఆపరేటర్లు:"

5) " షిఫ్ట్ ఆపరేటర్లు "

చిహ్నం	ఉదాహరణ	పేరు	వివరణ (ఇది ఏమి చేస్తుంది)
`>>`	`a >> b`	కుడి షిఫ్ట్	a సంఖ్య యొక్క బిట్‌లను b అంకెల ద్వారా కుడివైపుకి మారుస్తుంది.
`<<`	`c << d`	ఎడమ షిఫ్ట్	c సంఖ్య యొక్క బిట్‌లను d అంకెలతో ఎడమవైపుకి మారుస్తుంది.
`>>>`	`a >>> 2`	సంతకం చేయని కుడి షిఫ్ట్	a సంఖ్య యొక్క బిట్‌లను 2 అంకెలతో కుడివైపుకి మారుస్తుంది.

"ఇది ఎలాంటి వీధి మాయాజాలం?"

"నిజానికి అంతా చాలా సులభం. దీన్ని తనిఖీ చేయండి:"

ఉదాహరణ	సంఖ్యలు బిట్‌లుగా	బిట్స్‌గా ఫలితం	ఫలితం
`10 >> 1`	0000 101 0 >> 1	00000 101	5
`10 >> 2`	0000 101 0 >> 2	000000 10	2
`10 << 1`	0000 101 0 << 1	000 101 00	20
`10 << 2`	0000 101 0 << 2	00 101 000	40

"సంఖ్య యొక్క బిట్‌లను 1తో ఎడమవైపుకి మార్చడం సంఖ్యను 2తో గుణించడంతో సమానం. రెండు అంకెలతో మార్చడం 4 ద్వారా గుణించడం, మూడు అంకెలతో గుణించడంతో సమానం - 8 ద్వారా గుణించడం మరియు మొదలైనవి."

"కుడివైపు మారడం 2, 4, 8, 16, మొదలైన వాటి ద్వారా విభజించడానికి అనుగుణంగా ఉంటుంది."

"కానీ >>> మరియు >> ఆపరేటర్ల మధ్య తేడా ఏమిటి?"

"ప్రతికూల సంఖ్యలతో పని చేస్తున్నప్పుడు అవి విభిన్నంగా ఉంటాయి. ఎందుకంటే సంతకం చేసిన సంఖ్యలు గుర్తును సూచించడానికి ఎడమవైపు బిట్‌ను ఉపయోగిస్తాయి. ఫలితంగా, కుడివైపుకి మారినప్పుడు ప్రతికూల సంఖ్య ప్రతికూలంగా ఉండదు. కాబట్టి, వారు రెండు వేర్వేరు ఆపరేటర్‌లతో ముందుకు వచ్చారు. దీన్ని తనిఖీ చేయండి:"

వ్యక్తీకరణ	ఫలితం	వివరణ
1 000 1010 >> 1	11 000 101	ప్రతికూల సంఖ్య ప్రతికూలంగా ఉంటుంది. ప్రతికూల సంఖ్యల కోసం, ఇన్‌కమింగ్ బిట్‌లు 1 సెతో నిండి ఉంటాయి.
1 000 1010 >> 2	111 000 10
1 000 1010 >> 3	1111 000 1
1 000 1010 >>> 1	01 000 101	ప్రతికూల సంఖ్య ఇకపై ప్రతికూలంగా ఉండదు. ప్రతికూల సంఖ్యల కోసం, ఇన్‌కమింగ్ బిట్‌లు 0లతో నిండి ఉంటాయి.
1 000 1010 >>> 2	001 000 10
1 000 1010 >>> 3	0001 000 1

"షిఫ్ట్ చక్రీయమైనది కాదు. సంఖ్య యొక్క ఎడమ లేదా కుడి అంచుకు మించి కదిలే బిట్‌లు విస్మరించబడతాయి."

6) " అసైన్‌మెంట్ ఆపరేటర్లు "

"అసైన్‌మెంట్ అంటే ఏమిటో నాకు ముందే తెలుసు. అయినా 'ఆపరేటర్లు' అని ఎందుకు అంటున్నావు?"

"ఎందుకంటే వాటిలో చాలా ఉన్నాయి ☺"

ఆపరేటర్	అంటే ఏమిటి
`a += b;`	`a = a + b;`
`a -= b;`	`a = a - b;`
`a *= b;`	`a = a * b;`
`a %= b;`	`a = a % b;`
`a \|= b;`	`a = a \| b;`
`a &= b;`	`a = a & b;`

"మీకు లాజిక్ అర్థమైందని అనుకుంటున్నాను."

7) " పెంపు మరియు తగ్గింపు ఆపరేటర్లు "

సంజ్ఞామానం	ఉదాహరణ	వివరణ
`++`	`a++;` `++b;`	సంఖ్యను 1 పెంచుతుంది.
`--`	`d--;` `--i;`	సంఖ్య లేదా వేరియబుల్‌ను 1 ద్వారా తగ్గిస్తుంది.

"వేరియబుల్‌కు ముందు లేదా తర్వాత రెండు మైనస్ గుర్తులను ఉంచడం మధ్య తేడా ఉందా?"

"అవును, చాలా పెద్దది కానప్పటికీ ఉంది. ఈ ఆపరేటర్‌లలో ఒకరితో వేరియబుల్ ఎక్స్‌ప్రెషన్ లేదా అసైన్‌మెంట్‌లో భాగమైతే, అప్పుడు తేడాలు ఉంటాయి. నేను మీకు ఉదాహరణ ద్వారా చూపాలనుకుంటున్నాను:"

ఉదాహరణ	నిజంగా ఏమి జరుగుతుంది	వివరణ
`int a = 3;` `int b = ++a;`	`int a = 3;` `a = a + 1;` `int b = a;`	a మొదట 1 ద్వారా పెంచబడుతుంది, ఆపై అది వ్యక్తీకరణలో ఉపయోగించబడుతుంది.
`int a = 3;` `int b = a++;`	`int a = 3;` `int b = a;` `a = a + 1;`	a అనేది మొదట వ్యక్తీకరణలో ఉపయోగించబడుతుంది, ఆపై 1 ద్వారా పెరుగుతుంది.
`int a = 3;` `return a++;`	`int a = 3;` `int result = a;` `a = a + 1;` `return result;`	ఫంక్షన్ 3ని అందిస్తుంది, అయితే a విలువ 1 ద్వారా పెరుగుతుంది.
`int x = 5;` `x = ++x + ++x;`	`int x = 5;` `int a = x + 1;// The first term is 6` `x = a;` `int b = x + 1;// The second term is 7` `x = b;` `x = a + b;`	ఇక్కడ ఫలితం 13. మొదట, x 1 పెరుగుతుంది, మరియు ఈ విలువ మొదటి పదాన్ని భర్తీ చేస్తుంది, ఆపై x మళ్లీ 1 పెరుగుతుంది.

"ఓహో! బాగుంది!"

"మీకు నచ్చినందుకు నేను సంతోషిస్తున్నాను. కానీ, వ్యక్తీకరణ లేదా అసైన్‌మెంట్ లేకపోతే, తేడాలు లేవు:"

"x++ x = x + 1కి సమానం."

"++x అనేది x = x + 1కి సమానం."

"నేను దానిని గుర్తుంచుకోవాలి. ధన్యవాదాలు, బిలాబో."

8) " టెర్నరీ ఆపరేటర్ "

"ఈ ఆపరేటర్ కేవలం ఒకటి లేదా రెండు వేరియబుల్స్ లేదా ఎక్స్‌ప్రెషన్‌లను ఉపయోగించదు. ఇది ఒకేసారి మూడు వేరియబుల్స్ లేదా ఎక్స్‌ప్రెషన్‌లను ఉపయోగిస్తుంది:"

సంజ్ఞామానం	సమానమైన కోడ్:
`a ? b : c;`	`if (a)` `b` `else` `c`
`int min = a < b ? a : b;`	`if (a < b)` `min = a;` `else` `min = b;`
`return a != null ? a.length : 0;`	`if (a != null)` `return a.length;` `else` `return 0;`

"సరే, అది చాలా సౌకర్యవంతంగా ఉంటుంది."

"అవును. మరియు ఇది కాంపాక్ట్ మరియు కోడ్ చదవగలిగేలా ఉంది. దాన్ని ఉపయోగించి ఆనందించండి!"

9) " ఇతర "

"మీ సంగీత సేకరణను ఎంత చక్కగా నిర్వహించినప్పటికీ, మీరు ఇంకా "ఇతర" ఫోల్డర్‌ని సృష్టించాలి."

"అవును, సంగీతాన్ని వర్గీకరించాల్సిన ఎవరైనా పూర్తిగా అంగీకరిస్తారు."

"కాబట్టి, మరో ముగ్గురు ఆపరేటర్ల గురించి నేను మీకు చెప్పాలనుకుంటున్నాను:"

సంజ్ఞామానం	ఉదాహరణ	వివరణ
`()`	`(a + b) * c`	కుండలీకరణాలు ఆపరేటర్ ప్రాధాన్యతను పెంచుతాయి. కుండలీకరణాల్లోని విషయాలు ముందుగా అమలు చేయబడతాయి.
`[]`	`c [i] = c [i + 1];`	సూచిక ద్వారా శ్రేణి మూలకాన్ని పొందండి.
`.`	`int n = a.length;`	" డాట్ ఆపరేటర్ " ఒక వస్తువు యొక్క వేరియబుల్స్ మరియు పద్ధతులను యాక్సెస్ చేస్తుంది.

"మరియు, చివరగా, ఆపరేటర్ ప్రాధాన్యతను సంగ్రహించే పట్టిక ఇక్కడ ఉంది:"

ఆపరేటర్లు	ఉదాహరణలు
అత్యధిక ప్రాధాన్యత (ఆపరేటర్లు ఈ పట్టికలో వారి ఆర్డర్ ప్రకారం అమలు చేయబడతారు)
`()` `[]` `.`	`(a + b)` `c [i] = c [i] + 1`
`++` `--` `~` `!` `+` `-`	`i++; ++i;` `--j; a--;` `~c` `!f` `return +a;` `return -a;`
`*` `/` `%`	`a * b` `c / d` `a % b`
`+` `-`	`a + b` `c - d` `String s = "count"+"35";`
`>>` `<<` `>>>`	`a >> 3` `b << 2` `c >>> 3`
`<` `<=` `>` `>=`	`a < b` `a <= b` `c > b` `c >= b`
`==` `!=`	`a == 3` `a != 0`
`&`	`a & 7`
`^`	`a ^ b`
`\|`	`a \| b`
`&&`	`(a < b) && (a < c)`
`\|\|`	`(b != 0) \|\| (c != 0)`
`? : =`	`a > 0 ? a : -a;`
`=` `*=, /=, %=` `-=, +=` `<<=. >>=, >>>=` `&=, ^=. \|=`
అత్యల్ప ప్రాధాన్యత (చివరిగా ప్రదర్శించబడింది)