ఆపరేటర్లు అంటే ఒపెరాండ్ల విలువలను మార్చగల నిర్మాణాలు. 2 + 3 = 5 వ్యక్తీకరణను పరిగణించండి, ఇక్కడ 2 మరియు 3 ఉన్నాయి పనిచేస్తుంది మరియు + అంటారు ఆపరేటర్ . ఈ వ్యాసంలో ఆపరేటర్లు,ప్రారంభించడానికి మరియు జావాలో ఆపరేటర్లతో పనిచేయడానికి అవసరమైన నైపుణ్యాన్ని పొందడం లక్ష్యం.
జావా కింది రకాల ఆపరేటర్లకు మద్దతు ఇస్తుంది:
- అంకగణిత ఆపరేటర్లు
- అసైన్మెంట్ ఆపరేటర్లు
- లాజికల్ ఆపరేటర్లు
- రిలేషనల్ ఆపరేటర్లు
- యూనిరీ ఆపరేటర్లు
- బిట్‌వైస్ ఆపరేటర్లు
- టెర్నరీ ఆపరేటర్లు
- షిఫ్ట్ ఆపరేటర్లు
ఈ ఆపరేటర్లలో ఒక్కొక్కటి ఒక్కొక్కటిగా దృష్టి పెడదాం.
జావాలో అంకగణిత ఆపరేటర్లు
అదనంగా, వ్యవకలనం వంటి గణిత కార్యకలాపాలను నిర్వహించడానికి అంకగణిత ఆపరేటర్లను ఉపయోగిస్తారు. ఈ క్రింది పట్టికకు A = 10 మరియు B = 20 అని అనుకోండి.
ఆపరేటర్ | వివరణ | ఉదాహరణ |
+ అదనంగా | ఆపరేటర్ యొక్క ఇరువైపులా విలువలను జోడిస్తుంది | A + B = 30 |
- వ్యవకలనం | కుడి చేతి ఆపరేటర్‌ను ఎడమ చేతి ఆపరేటర్‌తో తీసివేస్తుంది | ఎ-బి = -10 |
* గుణకారం | ఆపరేటర్ యొక్క ఇరువైపులా విలువలను గుణించాలి | A * B = 200 |
/ విభజన జావాలో డబుల్ టు పూర్ణాంకానికి ప్రసారం | ఎడమ చేతి ఆపరేషన్‌ను కుడి చేతి ఆపరేటర్‌తో విభజిస్తుంది | A / B = 0 |
% మాడ్యులస్ | ఎడమ చేతి ఆపరేషన్‌ను కుడి చేతి ఆపరేషన్ ద్వారా విభజిస్తుంది మరియు మిగిలినది తిరిగి వస్తుంది | A% B = 0 |
క్రింది ఉదాహరణను పరిశీలించండి:
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ అంకగణిత ఆపరేటర్లు {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int A = 10 int B = 20 System.out.println (A + B) System.out.println (A - B) System.out.println (A * B) System.out.println (A / B) System.out.println (A% B)}}అవుట్పుట్:
30
-10
200
0
10
జావాలో అసైన్మెంట్ ఆపరేటర్లు
ఒక అసైన్మెంట్ ఆపరేటర్ ఒక ఆపరేటర్ ఉపయోగించారు కేటాయించవచ్చు వేరియబుల్‌కు కొత్త విలువ. దిగువ పట్టిక కోసం A = 10 మరియు B = 20 ume హించుకోండి.
| ఆపరేటర్ | వివరణ | ఉదాహరణ |
| = | కుడి వైపు ఒపెరాండ్ల నుండి ఎడమ వైపు ఒపెరాండ్ వరకు విలువలను కేటాయిస్తుంది | c = a + b |
| + = | ఇది ఎడమ ఒపెరాండ్‌కు కుడి ఒపెరాండ్‌ను జోడిస్తుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది | c + = a |
| - = | ఇది ఎడమ ఒపెరాండ్ నుండి కుడి ఒపెరాండ్‌ను తీసివేస్తుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది | c - = a |
| * = | ఇది కుడి ఒపెరాండ్‌ను ఎడమ ఒపెరాండ్‌తో గుణిస్తుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది | c * = a |
| / = | ఇది ఎడమ ఒపెరాండ్‌ను కుడి ఒపెరాండ్‌తో విభజిస్తుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది | c / = a |
| % = | ఇది రెండు ఒపెరాండ్‌లను ఉపయోగించి మాడ్యులస్ తీసుకుంటుంది మరియు ఫలితాన్ని ఎడమ ఒపెరాండ్‌కు కేటాయిస్తుంది | c% = a |
| ^ = | ఆపరేటర్లపై ఎక్స్‌పోనెన్షియల్ (పవర్) లెక్కింపును చేస్తుంది మరియు ఎడమ ఒపెరాండ్‌కు విలువను కేటాయించండి | c ^ = a |
క్రింది ఉదాహరణను పరిశీలించండి:
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ జావా ఆపరేటర్లు {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {int a = 10 int b = 20 int c System.out.println (c = a) // అవుట్పుట్ = 10 System.out.println (b + = a) // అవుట్పుట్ = 30 System.out.println (b - = a) // అవుట్పుట్ = 20 System.out.println (b * = a) // అవుట్పుట్ = 200 System.out.println (b / = a ) // అవుట్పుట్ = 2 System.out.println (b% = a) // అవుట్పుట్ = 0 System.out.println (b ^ = a) // అవుట్పుట్ = 0}}జావా ఆపరేటర్ల ట్యుటోరియల్‌లో ముందుకు వెళుతున్నప్పుడు, పోలిక ఆపరేటర్లు ఏమిటో చూద్దాం.
జావాలో రిలేషనల్ ఆపరేటర్లు
ఈ ఆపరేటర్లు వాటికి ఇరువైపులా ఉన్న విలువలను పోల్చి, వాటి మధ్య సంబంధాన్ని నిర్ణయిస్తారు. A = 10 మరియు B = 20 అని అనుకోండి.
ఆపరేటర్ | వివరణ | ఉదాహరణ |
== | రెండు ఒపెరాండ్ల విలువలు సమానంగా ఉంటే, అప్పుడు పరిస్థితి నిజం అవుతుంది. | (A == B) నిజం కాదు |
! = | రెండు ఒపెరాండ్ల విలువలు సమానంగా లేకపోతే, అప్పుడు పరిస్థితి నిజం అవుతుంది. | (అ! = బి) నిజం |
> | ఎడమ ఒపెరాండ్ యొక్క విలువ కుడి ఒపెరాండ్ విలువ కంటే ఎక్కువగా ఉంటే, అప్పుడు పరిస్థితి నిజం అవుతుంది. | (a> బి) నిజం కాదు |
ఎడమ ఒపెరాండ్ యొక్క విలువ కుడి ఒపెరాండ్ విలువ కంటే తక్కువగా ఉంటే, అప్పుడు పరిస్థితి నిజం అవుతుంది. | (కు | |
> = | ఎడమ ఒపెరాండ్ యొక్క విలువ కుడి ఒపెరాండ్ విలువ కంటే ఎక్కువ లేదా సమానంగా ఉంటే, అప్పుడు పరిస్థితి నిజం అవుతుంది. | (a> = b) నిజం కాదు |
ఎడమ ఒపెరాండ్ యొక్క విలువ కుడి ఒపెరాండ్ విలువ కంటే తక్కువ లేదా సమానంగా ఉంటే, అప్పుడు పరిస్థితి నిజం అవుతుంది. | (కు<= b) is true |
క్రింది ఉదాహరణను పరిశీలించండి:
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ జావా ఆపరేటర్స్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {int a = 10 int b = 20 System.out.println (a == b) // తప్పుడు తిరిగి వస్తుంది ఎందుకంటే 10 20 System.out కు సమానం కాదు .println (a! = b) // నిజమైనది 10 ఎందుకంటే 10 System.out.println (a> b) // తప్పుడు System.out.println (a = b) // ను తిరిగి ఇస్తుంది .println (ఎ<= b) // returns true } } తరువాత, లాజికల్ ఆపరేటర్లపై దృష్టి పెడదాం .
జావాలో లాజికల్ ఆపరేటర్లు
జావాలో ఉన్న లాజికల్ ఆపరేటర్లు క్రిందివి:
| ఆపరేటర్ | వివరణ | ఉదాహరణ |
| && (మరియు) | రెండు ఆపరేషన్లు నిజమైతే నిజం | కు<10 && a<20 |
| || (లేదా) | ఒపెరాండ్లలో ఏదైనా నిజమైతే నిజం | కు<10 || a<20 |
| ! (కాదు) | ఒపెరాండ్ తప్పు అయితే నిజం (ఒపెరాండ్‌ను పూర్తి చేస్తుంది) | ! (x<10 && a<20) |
క్రింది ఉదాహరణను పరిశీలించండి:
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ జావా ఆపరేటర్లు {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్)}ఇప్పుడు జావాలో అనామక ఆపరేటర్లను చూద్దాం.
జావాలో యునరీ ఆపరేటర్
యునరీ ఆపరేటర్లు ఒకే ఒపెరాండ్ అవసరం మరియు విలువను పెంచడానికి, విలువను తగ్గించడానికి లేదా తిరస్కరించడానికి ఉపయోగిస్తారు.
| ఆపరేటర్ | వివరణ | ఉదాహరణ |
| ++ | విలువను 1 ద్వారా పెంచుతుంది. పోస్ట్-ఇంక్రిమెంట్ మరియు ప్రీ-ఇంక్రిమెంట్ ఆపరేటర్లు ఉన్నారు | a ++ మరియు ++ a |
| - | విలువను 1 తగ్గిస్తుంది. పోస్ట్ తగ్గింపు మరియు ప్రీ డిక్మెంట్ ఆపరేటర్లు ఉన్నారు | a– లేదా –a |
| ! | బూలియన్ విలువను విలోమం చేయండి | ! కు |
కింది ఉదాహరణను పరిశీలించండి:
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ జావా ఆపరేటర్స్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {int a = 10 బూలియన్ బి = నిజమైన System.out.println (a ++) // రిటర్న్స్ 11 System.out.println (++ a) System.out .println (a--) System.out.println (- a) System.out.println (! b) // తప్పుడు తిరిగి ఇస్తుంది}}ముందుకు వెళుతున్నప్పుడు, జావాలో బిట్‌వైస్ ఆపరేటర్‌ను అర్థం చేసుకుందాం
జావాలో బిట్‌వైస్ ఆపరేటర్
బిట్‌వైస్ ఆపరేషన్లు నేరుగా తారుమారు చేస్తాయి బిట్స్ . అన్ని కంప్యూటర్లలో, సంఖ్యలు బిట్స్, సున్నాల శ్రేణి మరియు వాటితో సూచించబడతాయి. వాస్తవానికి, కంప్యూటర్‌లోని చాలా చక్కని ప్రతిదీ బిట్స్ ద్వారా సూచించబడుతుంది. దిగువ పట్టికకు A = 10 మరియు B = 20 అని అనుకోండి.
సేల్స్ఫోర్స్‌లో అనువర్తనాన్ని ఎలా సృష్టించాలి
| ఆపరేటర్ | వివరణ | ఉదాహరణ |
| & (మరియు) | ఇన్పుట్ యొక్క బిట్ మరియు బిట్ ద్వారా తిరిగి వస్తుంది | a & బి |
| | (OR) | ఇన్పుట్ విలువలను OR అందిస్తుంది | a | బి |
| ^ (XOR) | ఇన్పుట్ విలువల యొక్క XOR ను అందిస్తుంది | a ^ b |
| Comple (కాంప్లిమెంట్) | ఒకరి పూరకంగా తిరిగి వస్తుంది. (అన్ని బిట్స్ తారుమారు) | ~ a |
క్రింద చూపిన ఉదాహరణను పరిశీలించండి:
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ జావా ఆపరేటర్స్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) బి) // 63 = 111111 System.out.println (a ^ b) // 55 = 11011 System.out.println (~ a) // - 59}తరువాత, జావాలోని టెర్నరీ ఆపరేటర్‌పై దృష్టి పెడదాం
జావాలో టెర్నరీ ఆపరేటర్లు
టెర్నరీ ఆపరేటర్ అనేది షరతులతో కూడిన ఆపరేటర్, ఇది పోలికలు చేసేటప్పుడు కోడ్ యొక్క పొడవును తగ్గిస్తుంది మరియు . ఈ పద్ధతి if-else మరియు nested if-else స్టేట్మెంట్లను ఉపయోగించటానికి ప్రత్యామ్నాయం. ఈ ఆపరేటర్ అమలు యొక్క క్రమం ఎడమ నుండి కుడికి ఉంటుంది.
సింటాక్స్:
(పరిస్థితి)? (స్టేట్మెంట్ 1): (స్టేట్మెంట్ 2)
- పరిస్థితి: మూల్యాంకనం చేయవలసిన వ్యక్తీకరణ ఇది బూలియన్ విలువను అందిస్తుంది.
- ప్రకటన 1: పరిస్థితి నిజమైన స్థితికి వస్తే అది అమలు చేయవలసిన ప్రకటన.
- ప్రకటన 2: షరతు తప్పుడు స్థితిలో ఉంటే అది అమలు చేయవలసిన ప్రకటన.
క్రింది ఉదాహరణను పరిశీలించండి:
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ జావా ఆపరేటర్లు {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {int a = 20, b = 10, c = 30, res res = ((a> b)? (a> c)? a: c: (b> c)? b: c) System.out.println ('మూడు సంఖ్యల గరిష్టం =' + res)}}అవుట్పుట్ - గరిష్టంగా మూడు సంఖ్యలు = 30
చివరి జావా ఆపరేటర్‌కి ముందుకు వెళుతున్నప్పుడు, జావాలోని షిఫ్ట్ ఆపరేటర్లను అర్థం చేసుకుందాం.
జావాలో షిఫ్ట్ ఆపరేటర్లు
షిఫ్ట్ ఆపరేటర్లుసంఖ్య యొక్క బిట్లను ఎడమ లేదా కుడి వైపుకు మార్చడానికి ఉపయోగిస్తారు, తద్వారా సంఖ్యను గుణించడం లేదా విభజించడం. మూడు రకాల షిఫ్ట్ ఆపరేటర్లు ఉన్నాయి, అవి లెఫ్ట్ షిఫ్ట్ ఆపరేటర్ ()<>) మరియు సంతకం చేయని కుడి షిఫ్ట్ ఆపరేటర్ (>>>).
సింటాక్స్:
సంఖ్య shift_op సంఖ్య_ స్థలాల_శిక్ష
కింది ఉదాహరణను పరిశీలించండి:
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ జావా ఆపరేటర్స్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {int a = 58 System.out.println (a<>2) // రిటర్న్స్ 14 = 1110 System.out.println (a >>> 2) // రిటర్న్స్ 14}}దీనితో, మేము వివిధ జావా ఆపరేటర్లపై ఈ వ్యాసం చివరకి వచ్చాము. ఈ వ్యాసం మీకు సమాచారం ఇచ్చిందని నేను నమ్ముతున్నాను.
చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, ఈ జావా ఇంటర్వ్యూ ప్రశ్నలతో పాటుగా, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలోని ఆపరేటర్లు” వ్యాసం యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.