జావా వేరియబుల్స్ మరియు విలువలపై కార్యకలాపాలను నిర్వహించడానికి ఉపయోగించే అనేక రకాల ఆపరేటర్లను కలిగి ఉంది. జావాలోని ప్రాథమిక ఆపరేటర్లు ఇక్కడ ఉన్నారు:
ఖచ్చితంగా, జావాలోని అంకగణిత ఆపరేటర్ల పట్టిక ఇక్కడ ఉంది:
1. Arithmetic Operators అరిథ్మెటిక్ ఆపరేటర్లు
| ఆపరేటర్ | వివరణ | ఉదాహరణ |
|---|---|---|
| + | అదనంగా | int sum = 5 + 3; |
| - | తీసివేత | int difference = 5 - 3; |
| * | గుణకారం | int product = 5 * 3; |
| / | విభజన | int quotient = 5 / 3; |
| % | మాడ్యులస్ | int remainder = 5 % 3; |
ఉదాహరణలలో, 5 మరియు 3 విలువలు ప్రతి అంకగణిత ఆపరేటర్ యొక్క ఆపరేషన్‌ను ప్రదర్శించడానికి ఉపయోగించబడతాయి. ప్రతి ఆపరేషన్ యొక్క ఫలిత విలువ రకం యొక్క వేరియబుల్‌కు కేటాయించబడుతుంది int. మాడ్యులస్ ఆపరేటర్ విభజన ఆపరేషన్ యొక్క శేషాన్ని తిరిగి ఇస్తుందని గమనించండి, ఇది ఈ సందర్భంలో 2 ( 5 / 3శేషం 2తో 1కి సమానం).
- అంకగణిత ఆపరేటర్లు: సంఖ్యా డేటా రకాలపై గణిత కార్యకలాపాలను నిర్వహించడానికి అంకగణిత ఆపరేటర్లను ఉపయోగిస్తారు.
- జోడింపు (+): రెండు విలువలు లేదా వేరియబుల్‌లను జోడిస్తుంది.
- వ్యవకలనం (-): ఒక విలువ లేదా వేరియబుల్‌ను మరొక దాని నుండి తీసివేస్తుంది.
- గుణకారం (*): రెండు విలువలు లేదా వేరియబుల్‌లను గుణించడం.
- డివిజన్ (/): ఒక విలువ లేదా వేరియబుల్‌ను మరొక దానితో భాగిస్తుంది.
- మాడ్యులస్ (%): విభజన ఆపరేషన్ యొక్క మిగిలిన భాగాన్ని అందిస్తుంది.
- అసైన్‌మెంట్ ఆపరేటర్లు: అసైన్‌మెంట్ ఆపరేటర్లు వేరియబుల్స్‌కు విలువలను కేటాయించడానికి ఉపయోగిస్తారు.
- సాధారణ అసైన్‌మెంట్ (=): వేరియబుల్‌కు విలువను కేటాయిస్తుంది.
- సమ్మేళనం అసైన్‌మెంట్ (+=, -=, *=, /=, %=): ఒక అంకగణిత ఆపరేషన్‌ని అమలు చేసి, ఆపై ఫలితాన్ని వేరియబుల్‌కి కేటాయిస్తుంది.
- పోలిక ఆపరేటర్లు: పోలిక ఆపరేటర్లు రెండు విలువలు లేదా వేరియబుల్స్ పోల్చడానికి ఉపయోగిస్తారు.
- (==)కి సమానం: రెండు విలువలు లేదా వేరియబుల్‌లు సమానంగా ఉంటే ఒప్పు అని చూపుతుంది.
- (!=)కి సమానం కాదు: రెండు విలువలు లేదా వేరియబుల్‌లు సమానంగా లేకుంటే ఒప్పు అని చూపుతుంది.
- (>) కంటే ఎక్కువ: మొదటి విలువ లేదా వేరియబుల్ రెండవదాని కంటే ఎక్కువగా ఉంటే ఒప్పు అని చూపుతుంది.
- (<) కంటే తక్కువ: మొదటి విలువ లేదా వేరియబుల్ రెండవదాని కంటే తక్కువగా ఉన్నట్లయితే నిజం చూపబడుతుంది.
- (>=) కంటే ఎక్కువ లేదా సమానం: మొదటి విలువ లేదా వేరియబుల్ రెండవ దాని కంటే ఎక్కువ లేదా సమానంగా ఉంటే ఒప్పు అని చూపుతుంది.
- (<=) కంటే తక్కువ లేదా సమానం: మొదటి విలువ లేదా వేరియబుల్ రెండవ దాని కంటే తక్కువ లేదా సమానంగా ఉంటే నిజం చూపబడుతుంది.
- లాజికల్ ఆపరేటర్లు: బూలియన్ డేటా రకాలపై తార్కిక కార్యకలాపాలను నిర్వహించడానికి లాజికల్ ఆపరేటర్లు ఉపయోగించబడతారు.
- మరియు (&&): రెండు షరతులు నిజమైతే నిజమని చూపుతుంది.
- OR (||): ఏదైనా షరతు నిజమైతే నిజాన్ని చూపుతుంది.
- కాదు (!): బూలియన్ విలువకు వ్యతిరేకతను అందిస్తుంది.
- బిట్‌వైస్ ఆపరేటర్లు: బైనరీ సంఖ్యల వ్యక్తిగత బిట్‌లపై కార్యకలాపాలను నిర్వహించడానికి బిట్‌వైస్ ఆపరేటర్లను ఉపయోగిస్తారు.
- మరియు (&): రెండు బిట్‌లు 1 అయితే ప్రతి బిట్‌ను 1కి సెట్ చేస్తుంది.
- OR (|): బిట్ 1 అయితే ప్రతి బిట్‌ను 1కి సెట్ చేస్తుంది.
- XOR (^): ఒక్క బిట్ 1 అయితే ప్రతి బిట్‌ను 1కి సెట్ చేస్తుంది.
- కాదు (~): అన్ని బిట్‌లను విలోమం చేస్తుంది.
- ఎడమ షిఫ్ట్ (<<): బిట్‌లను ఎడమవైపుకి మారుస్తుంది, సున్నాలతో నింపుతుంది.
- రైట్ షిఫ్ట్ (>>): బిట్‌లను కుడివైపుకి మారుస్తుంది, ఎడమవైపు బిట్ యొక్క గుర్తును బట్టి సున్నాలు లేదా వాటిని పూరించండి.
- సంతకం చేయని కుడి షిఫ్ట్ (>>>): బిట్‌లను కుడివైపుకి మారుస్తుంది, సున్నాలతో నింపుతుంది.
- షరతులతో కూడిన ఆపరేటర్: షరతు ఆధారంగా వేరియబుల్‌కు రెండు విలువలలో ఒకదాన్ని కేటాయించడానికి షరతులతో కూడిన ఆపరేటర్ (?:) ఉపయోగించబడుతుంది.
- పరిస్థితి ? value1 : value2: షరతు ఒప్పు అయితే, value1 వేరియబుల్‌కు కేటాయించబడుతుంది, లేకపోతే value2 కేటాయించబడుతుంది.
ఆపరేటర్ల ప్రాధాన్యత క్రమం వ్యక్తీకరణల ఫలితాన్ని ప్రభావితం చేస్తుందని గమనించండి. వ్యక్తీకరణలను సమూహపరచడానికి మరియు మూల్యాంకన క్రమాన్ని అమలు చేయడానికి కుండలీకరణాలను ఉపయోగించవచ్చు....
2. Relational Operators రిలేషనల్ ఆపరేటర్లు
ఖచ్చితంగా, జావాలో రిలేషనల్ ఆపరేటర్లు ఇక్కడ ఉన్నారు:
| ఆపరేటర్ | వివరణ | ఉదాహరణ |
|---|---|---|
| == | సమానంగా | boolean isEqual = (5 == 3);// తప్పు |
| != | సమానం కాదు | boolean isNotEqual = (5 != 3);// నిజం |
| > | అంతకన్నా ఎక్కువ | boolean isGreaterThan = (5 > 3);// నిజం |
| < | కంటే తక్కువ | boolean isLessThan = (5 < 3);// తప్పు |
| >= | దీని కంటే ఎక్కువ లేదా సమానం | boolean isGreaterThanOrEqualTo = (5 >= 3);// నిజం |
| <= | దీని కంటే తక్కువ లేదా సమానం | boolean isLessThanOrEqualTo = (5 <= 3);// తప్పు |
ఉదాహరణలలో, ప్రతి రిలేషనల్ ఆపరేటర్ యొక్క ఆపరేషన్‌ను ప్రదర్శించడానికి 5 మరియు 3 విలువలు ఉపయోగించబడతాయి. ప్రతి ఆపరేషన్ యొక్క ఫలిత బూలియన్ విలువ రకం యొక్క వేరియబుల్‌కు కేటాయించబడుతుంది boolean. ఆపరేటర్ ==సమానత్వం కోసం తనిఖీ చేస్తాడు, అయితే !=ఆపరేటర్ అసమానత కోసం తనిఖీ చేస్తాడు. మరియు ఆపరేటర్లు ఆపరేటర్ల సాపేక్ష పరిమాణాన్ని తనిఖీ చేస్తారు, అయితే మరియు ఆపరేటర్లు పరిమాణం మరియు >సమానత్వం కోసం తనిఖీ చేస్తారు.<>=<=
3. Bitwise Operators బిట్‌వైస్ ఆపరేటర్లు
ఖచ్చితంగా, జావాలోని బిట్‌వైజ్ ఆపరేటర్లు ఇక్కడ ఉన్నాయి:
| ఆపరేటర్ | వివరణ | ఉదాహరణ |
|---|---|---|
| & | బిట్‌వైస్ మరియు | int result = 5 & 3; // 1 |
| | | బిట్‌వైస్ OR | int result = 5 | 3; // 7 |
| ^ | బిట్‌వైస్ XOR | int result = 5 ^ 3; // 6 |
| ~ | బిట్‌వైస్ కాదు | int result = ~5; // -6 |
| << | ఎడమ షిఫ్ట్ | int result = 5 << 1; // 10 |
| >> | కుడి షిఫ్ట్ | int result = 5 >> 1; // 2 |
| >>> | సంతకం చేయని కుడి షిఫ్ట్ | int result = -5 >>> 1; // 2147483645 |
ఉదాహరణలలో, 5 మరియు 3 విలువలు బిట్‌వైస్ ఆపరేటర్ల ఆపరేషన్‌ను ప్రదర్శించడానికి ఉపయోగించబడతాయి. ప్రతి ఆపరేషన్ యొక్క ఫలిత విలువ రకం యొక్క వేరియబుల్‌కు కేటాయించబడుతుంది int. &ఆపరేటర్ బిట్‌వైస్ AND, |ఆపరేటర్ బిట్‌వైస్ OR మరియు ^ఆపరేటర్ బిట్‌వైస్ XOR నిర్వహిస్తారని గమనించండి . ఆపరేటర్ ~ఒపెరాండ్ యొక్క అన్ని బిట్‌లను విలోమం చేస్తూ బిట్‌వైస్ NOTని నిర్వహిస్తాడు. ఆపరేటర్ <<పేర్కొన్న స్థానాల సంఖ్య ద్వారా బిట్‌లను ఎడమవైపుకు మారుస్తాడు, అయితే ఆపరేటర్ >>పేర్కొన్న స్థానాల సంఖ్య ద్వారా బిట్‌లను కుడివైపుకి మారుస్తాడు. ఆపరేటర్ >>>సంతకం చేయని కుడి షిఫ్ట్‌ని నిర్వహిస్తాడు, బిట్‌లను కుడివైపుకి మారుస్తాడు మరియు ఎడమవైపు ఉన్న బిట్‌లను సున్నాలతో నింపాడు.
4 . Logical Operators లాజికల్ ఆపరేటర్లు
ఖచ్చితంగా, జావాలోని లాజికల్ ఆపరేటర్లు ఇక్కడ ఉన్నాయి:
| ఆపరేటర్ | వివరణ | ఉదాహరణ |
|---|---|---|
| && | షరతులతో కూడిన మరియు | boolean result = (5 > 3) && (2 < 4);// నిజం |
| || | షరతులతో కూడిన OR | boolean result = (5 < 3) || (2 < 4);// నిజం |
| ! | లాజికల్ కాదు | boolean result = !(5 > 3);// తప్పు |
ఉదాహరణలలో, వ్యక్తీకరణలు (5 > 3)మరియు (2 < 4)లాజికల్ ఆపరేటర్ల ఆపరేషన్‌ను ప్రదర్శించడానికి ఉపయోగించబడతాయి. ప్రతి ఆపరేషన్ యొక్క ఫలిత బూలియన్ విలువ రకం యొక్క వేరియబుల్‌కు కేటాయించబడుతుంది boolean. ఆపరేటర్ షరతులతో కూడిన ANDని నిర్వహిస్తారని గమనించండి &&, మొదటి ఒపెరాండ్ నిజమైతే మాత్రమే రెండవ ఆపరాండ్‌ను మూల్యాంకనం చేస్తుంది. ఆపరేటర్ ||షరతులతో కూడిన ORని నిర్వహిస్తారు, మొదటి ఆపరాండ్ తప్పు అయితే మాత్రమే రెండవ ఆపరాండ్‌ను మూల్యాంకనం చేస్తుంది. ఆపరేటర్ !ఓపెరాండ్ యొక్క బూలియన్ విలువను తలక్రిందులు చేస్తూ లాజికల్ NOTని నిర్వహిస్తుంది...
5 . Assignment Operators అసైన్‌మెంట్ ఆపరేటర్లు
ఖచ్చితంగా, జావాలోని అసైన్‌మెంట్ ఆపరేటర్లు ఇక్కడ ఉన్నాయ్:
| Operator | Description | Example |
|---|---|---|
| = | Simple assignment | int x = 5; |
| += | Addition assignment | int x = 5; x += 3; // equivalent to x = x + 3 |
| -= | Subtraction assignment | int x = 5; x -= 3; // equivalent to x = x - 3 |
| *= | Multiplication assignment | int x = 5; x *= 3; // equivalent to x = x * 3 |
| /= | Division assignment | int x = 5; x /= 3; // equivalent to x = x / 3 |
| %= | Modulus assignment | int x = 5; x %= 3; // equivalent to x = x % 3 |
| <<= | Left shift assignment | int x = 5; x <<= 1; // equivalent to x = x << 1 |
| >>= | Right shift assignment | int x = 5; x >>= 1; // equivalent to x = x >> 1 |
| &= | Bitwise AND assignment | int x = 5; x &= 3; // equivalent to x = x & 3 |
| ^= | Bitwise XOR assignment | int x = 5; x ^= 3; // equivalent to x = x ^ 3 |
| |= | Bitwise OR assignment | int x = 5; x |= 3; // equivalent to x = x | 3 |
ఉదాహరణలలో, xఅసైన్‌మెంట్ ఆపరేటర్ల ఆపరేషన్‌ను ప్రదర్శించడానికి వేరియబుల్ ఉపయోగించబడుతుంది. ప్రతి చర్య యొక్క ఫలిత విలువ వేరియబుల్‌కు కేటాయించబడుతుంది x. ప్రతి ఆపరేటర్ వేరియబుల్ మరియు కుడి ఒపెరాండ్‌పై పేర్కొన్న ఆపరేషన్‌ను నిర్వహిస్తుందని గమనించండి, ఆపై ఆపరేటర్ యొక్క ఎడమ వైపున ఉన్న వేరియబుల్‌కు ఫలితాన్ని కేటాయిస్తుంది. ఉదాహరణకు, x += 3కు సమానం x = x + 3.
6. Miscellaneous Operators ఇతర ఆపరేటర్లు
ఖచ్చితంగా, జావాలోని ఇతర ఆపరేటర్లు ఇక్కడ ఉన్నాయ్::
| Operator | Description | Example |
|---|---|---|
| ?: | Ternary operator | int result = (5 > 3) ? 1 : 0; // result is 1 |
| instanceof | Type comparison operator | if (obj instanceof String) { ... } |
| :: | Method reference operator | List<Integer> numbers = Arrays.asList(1, 2, 3); numbers.forEach(System.out::println); |
ఉదాహరణలలో, వ్యక్తీకరణలు (5 > 3)మరియు objటెర్నరీ ఆపరేటర్ యొక్క ఆపరేషన్ మరియు ఆపరేటర్ యొక్క ఉదాహరణను వరుసగా ప్రదర్శించడానికి ఉపయోగిస్తారు. టెర్నరీ ఆపరేటర్ యొక్క ఫలితం రకం యొక్క వేరియబుల్‌కు కేటాయించబడుతుంది int, అయితే ఆబ్జెక్ట్ ఒక నిర్దిష్ట తరగతికి సంబంధించిన ఉదాహరణ కాదా అని తనిఖీ చేయడానికి if స్టేట్‌మెంట్‌లో ఆపరేటర్ యొక్క ఉదాహరణ ఉపయోగించబడుతుంది.
డబుల్ కోలన్ ::ఆపరేటర్ పద్ధతి సూచన కోసం ఉపయోగించబడుతుంది. ఇది ఒక పద్ధతికి సూచనను ఒక వస్తువు వలె పంపడానికి అనుమతిస్తుంది మరియు ఇది తరచుగా ఫంక్షనల్ ఇంటర్‌ఫేస్‌లు మరియు లాంబ్డా వ్యక్తీకరణలతో కలిపి ఉపయోగించబడుతుంది. ఉదాహరణలో, పూర్ణాంకాల జాబితాపై పునరావృతం చేయడానికి ఇంటర్‌ఫేస్ forEachయొక్క పద్ధతి ఉపయోగించబడుతుంది మరియు ఆపరేటర్‌ని ఉపయోగించి తరగతి యొక్క పద్ధతి సూచనగా ఆమోదించబడుతుంది .ListprintlnSystem::
7. Precedence of Java Operators జావా ఆపరేటర్ల ప్రాధాన్యత వర్గం
ఖచ్చితంగా, ఇక్కడ జావా ఆపరేటర్ల ప్రాధాన్యత పట్టిక ఉంది, వారి అనుబంధం (ఎడమ నుండి కుడికి లేదా కుడి నుండి ఎడమకు)తో పాటు వర్గం వారీగా జాబితా చేయబడింది:
| Category | Operator(s) | Associativity |
|---|---|---|
| Postfix | expression++, expression-- | Left-to-right |
| Unary | ++expression, --expression, +expression, -expression, !expression, ~expression, type(expression) | Right-to-left |
| Multiplicative | *, /, % | Left-to-right |
| Additive | +, - | Left-to-right |
| Shift | <<, >>, >>> | Left-to-right |
| Relational | <, <=, >, >=, instanceof | Left-to-right |
| Equality | ==, != | Left-to-right |
| Bitwise AND | & | Left-to-right |
| Bitwise XOR | ^ | Left-to-right |
| Bitwise OR | ` | ` |
| Logical AND | && | Left-to-right |
| Logical OR | || | Left-to-right |
| Ternary | expression ? expression : expression | Right-to-left |
| Assignment | =, +=, -=, *=, /=, %=, <<=, >>=, >>>=, &=, ^=, |=, => | Right-to-left |
పట్టికలో, ప్రతి వర్గంలోని ఆపరేటర్లు ప్రాధాన్యత తగ్గే క్రమంలో జాబితా చేయబడతారు, అధిక ప్రాధాన్యత కలిగిన ఆపరేటర్లు ముందుగా జాబితా చేయబడతారు. ప్రతి ఆపరేటర్‌కు అసోసియేటివిటీ కూడా పేర్కొనబడింది, ఆపరేటర్ ఎడమ నుండి కుడికి లేదా కుడి నుండి ఎడమకు మూల్యాంకనం చేయబడిందా అని సూచిస్తుంది. వ్యక్తీకరణలో ఒకే ప్రాధాన్యత కలిగిన బహుళ ఆపరేటర్లు ఉన్నప్పుడు ఆపరేషన్‌లు నిర్వహించబడే క్రమాన్ని ఆపరేటర్ యొక్క అనుబంధం నిర్ణయిస్తుందని గమనించండి....
