ஆபரேட்டர்கள் என்பது ஓபராண்ட்களின் மதிப்புகளைக் கையாளக்கூடிய கட்டுமானங்கள். 2 + 3 = 5 என்ற வெளிப்பாட்டைக் கவனியுங்கள், இங்கே 2 மற்றும் 3 உள்ளன செயல்படுகிறது மற்றும் + என்று அழைக்கப்படுகிறது ஆபரேட்டர் . இந்த கட்டுரையில் ஆபரேட்டர்கள்,தொடங்குவதற்கும் ஜாவாவில் ஆபரேட்டர்களுடன் பணியாற்றுவதற்கும் தேவையான நிபுணத்துவத்தைப் பெறுவதே குறிக்கோள்.
ஜாவா பின்வரும் வகை ஆபரேட்டர்களை ஆதரிக்கிறது:
- எண்கணித ஆபரேட்டர்கள்
- அசைன்மென்ட் ஆபரேட்டர்கள்
- தருக்க ஆபரேட்டர்கள்
- தொடர்புடைய ஆபரேட்டர்கள்
- யூனரி ஆபரேட்டர்கள்
- பிட்வைஸ் ஆபரேட்டர்கள்
- டெர்னரி ஆபரேட்டர்கள்
- ஷிப்ட் ஆபரேட்டர்கள்
இந்த ஆபரேட்டர்கள் ஒவ்வொன்றிலும் ஒவ்வொன்றாக கவனம் செலுத்துவோம்.
ஜாவாவில் எண்கணித ஆபரேட்டர்கள்
கூட்டல், கழித்தல் போன்ற கணித செயல்பாடுகளைச் செய்ய எண்கணித ஆபரேட்டர்கள் பயன்படுத்தப்படுகின்றன. கீழேயுள்ள அட்டவணைக்கு A = 10 மற்றும் B = 20 என்று வைத்துக் கொள்ளுங்கள்.
ஆபரேட்டர் | விளக்கம் | உதாரணமாக |
+ கூட்டல் | ஆபரேட்டரின் இருபுறமும் மதிப்புகளைச் சேர்க்கிறது | A + B = 30 |
- கழித்தல் | வலது கை ஆபரேட்டரை இடது கை ஆபரேட்டருடன் கழிக்கிறது | எ-பி = -10 |
* பெருக்கல் | ஆபரேட்டரின் இருபுறமும் மதிப்புகளை பெருக்குகிறது | எ * பி = 200 html இல் உள்ளமை அட்டவணைகள் செய்வது எப்படி |
/ பிரிவு | இடது கை செயல்பாட்டை வலது கை ஆபரேட்டருடன் பிரிக்கிறது | எ / பி = 0 |
% மாடுலஸ் | இடது கை இயக்கத்தை வலது கை இயக்கத்தால் பிரித்து மீதமுள்ளவை | ஒரு% பி = 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 எனக் கொள்ளுங்கள்.
| ஆபரேட்டர் | விளக்கம் | உதாரணமாக |
| = | வலது பக்க இயக்கங்களிலிருந்து இடது பக்க இயக்கத்திற்கு மதிப்புகளை ஒதுக்குகிறது | c = a + b |
| + = | இது இடது இயக்கத்திற்கு வலது இயக்கத்தைச் சேர்க்கிறது மற்றும் முடிவை இடது இயக்கத்திற்கு ஒதுக்குகிறது | c + = அ |
| - = | இது இடது இயக்கத்திலிருந்து வலது இயக்கத்தை கழித்து, முடிவை இடது இயக்கத்திற்கு ஒதுக்குகிறது | c - = a |
| * = | இது இடது இயக்கத்துடன் வலது இயக்கத்தை பெருக்கி, முடிவை இடது இயக்கத்திற்கு ஒதுக்குகிறது | c * = அ |
| / = | இது இடது இயக்கத்தை வலது இயக்கத்துடன் பிரிக்கிறது மற்றும் முடிவை இடது இயக்கத்திற்கு ஒதுக்குகிறது | c / = a |
| % = | இது இரண்டு ஓபராண்ட்களைப் பயன்படுத்தி மாடுலஸை எடுத்து, முடிவை இடது இயக்கத்திற்கு ஒதுக்குகிறது | c% = அ |
| ^ = | ஆபரேட்டர்கள் மீது அதிவேக (சக்தி) கணக்கீட்டைச் செய்கிறது மற்றும் இடது இயக்கத்திற்கு மதிப்பை ஒதுக்குகிறது | c ^ = அ |
கீழே உள்ள உதாரணத்தைக் கவனியுங்கள்:
தொகுப்பு எடுரேகா பொது வகுப்பு ஜாவா ஆபரேட்டர்கள் {பொது நிலையான வெற்றிட மெயின் (சரம் [] ஆர்க்ஸ்) {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> b) உண்மை இல்லை |
இடது இயக்கத்தின் மதிப்பு வலது இயக்கத்தின் மதிப்பை விட குறைவாக இருந்தால், நிபந்தனை உண்மையாகிறது. | (க்கு | |
> = | இடது இயக்கத்தின் மதிப்பு வலது இயக்கத்தின் மதிப்பை விட அதிகமாகவோ அல்லது சமமாகவோ இருந்தால், நிபந்தனை உண்மையாகிறது. | (a> = b) உண்மை இல்லை |
இடது இயக்கத்தின் மதிப்பு வலது இயக்கத்தின் மதிப்பை விட குறைவாகவோ அல்லது சமமாகவோ இருந்தால், நிபந்தனை உண்மையாகிறது. | (க்கு<= b) is true |
கீழே உள்ள உதாரணத்தைக் கவனியுங்கள்:
தொகுப்பு எடுரேகா பொது வகுப்பு ஜாவா ஆபரேட்டர்கள் {பொது நிலையான வெற்றிட மெயின் (சரம் [] ஆர்க்ஸ்) {int a = 10 int b = 20 System.out.println (a == b) // தவறானது, ஏனெனில் 10 20 System.out க்கு சமமாக இல்லை .println (a! = b) // உண்மைக்குத் திரும்புகிறது, ஏனெனில் 10 ஆனது 20 System.out.println (a> b) // தவறான System.out.println (a = b) // ஐத் தருகிறது தவறான System.out .println (அ<= b) // returns true } } அடுத்து, தருக்க ஆபரேட்டர்கள் மீது கவனம் செலுத்துவோம் .
ஜாவாவில் தருக்க ஆபரேட்டர்கள்
ஜாவாவில் உள்ள லாஜிக்கல் ஆபரேட்டர்கள் பின்வருமாறு:
| ஆபரேட்டர் | விளக்கம் | உதாரணமாக |
| && (மற்றும்) | இரண்டு செயல்பாடுகளும் உண்மை என்றால் உண்மை | க்கு<10 && a<20 |
| || (அல்லது) | ஓபராண்ட்களில் ஒன்று உண்மை என்றால் உண்மை | க்கு<10 || a<20 |
| ! (இல்லை) | ஒரு செயல்பாடு தவறானது என்றால் உண்மை (செயல்பாட்டை நிறைவு செய்கிறது) | ! (எக்ஸ்<10 && a<20) |
கீழே உள்ள உதாரணத்தைக் கவனியுங்கள்:
தொகுப்பு எடுரேகா பொது வகுப்பு ஜாவா ஆபரேட்டர்கள் {பொது நிலையான வெற்றிட மெயின் (சரம் [] ஆர்க்ஸ்)}இப்போது ஜாவாவில் unary ஆபரேட்டர்களைப் பார்ப்போம்.
ஜாவாவில் யூனரி ஆபரேட்டர்
ஒற்றைப்படை ஆபரேட்டர்கள் ஒரு ஒற்றை செயல்பாடு தேவை மற்றும் ஒரு மதிப்பை அதிகரிக்க, குறைக்க அல்லது மதிப்பை மறுக்க பயன்படுகிறது.
| ஆபரேட்டர் | விளக்கம் | உதாரணமாக |
| ++ | மதிப்பை 1 ஆல் அதிகரிக்கிறது. பிந்தைய அதிகரிப்பு மற்றும் முன்-அதிகரிப்பு ஆபரேட்டர்கள் உள்ளனர் | a ++ மற்றும் ++ a |
| - | மதிப்பை 1 ஆல் குறைக்கிறது. பிந்தைய குறைப்பு மற்றும் முன் குறைப்பு ஆபரேட்டர்கள் உள்ளனர் | a– அல்லது –அ |
| ! | பூலியன் மதிப்பை மாற்றவும் | ! க்கு |
பின்வரும் எடுத்துக்காட்டைக் கவனியுங்கள்:
தொகுப்பு எடுரேகா பொது வகுப்பு ஜாவா ஆபரேட்டர்கள் {பொது நிலையான வெற்றிட மெயின் (சரம் [] ஆர்க்ஸ்) {int a = 10 பூலியன் b = true 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 & b |
| | (அல்லது) | உள்ளீட்டு மதிப்புகளின் OR ஐ வழங்குகிறது | a | ஆ |
| X (XOR) | உள்ளீட்டு மதிப்புகளின் XOR ஐ வழங்குகிறது | a ^ b |
| ~ (நிரப்புதல்) | ஒருவரின் நிரப்புதலை வழங்குகிறது. (அனைத்து பிட்களும் தலைகீழ்) | ~ அ |
கீழே காட்டப்பட்டுள்ள எடுத்துக்காட்டைக் கவனியுங்கள்:
தொகுப்பு எடுரேகா பொது வகுப்பு ஜாவா ஆபரேட்டர்கள் {பொது நிலையான வெற்றிட மெயின் (சரம் [] ஆர்க்ஸ்) ஆ) // 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 ('மூன்று எண்களின் அதிகபட்சம் =' + ரெஸ்)}}வெளியீடு - மூன்று எண்களின் அதிகபட்சம் = 30
கடைசி ஜாவா ஆபரேட்டருக்கு முன்னேறி, ஜாவாவில் ஷிப்ட் ஆபரேட்டர்களைப் புரிந்துகொள்வோம்.
ஜாவாவில் ஷிப்ட் ஆபரேட்டர்கள்
ஷிப்ட் ஆபரேட்டர்கள்ஒரு எண்ணின் பிட்களை இடது அல்லது வலதுபுறமாக மாற்ற பயன்படுகிறது, இதன் மூலம் எண்ணைப் பெருக்கி அல்லது வகுக்கலாம். மூன்று வெவ்வேறு வகையான ஷிப்ட் ஆபரேட்டர்கள் உள்ளன, அதாவது இடது ஷிப்ட் ஆபரேட்டர் ()<>) மற்றும் கையொப்பமிடாத வலது ஷிப்ட் ஆபரேட்டர் (>>>).
தொடரியல்:
எண் shift_op எண்_ இடங்கள்_ இடங்களுக்கு_ மாற்றம்
பின்வரும் எடுத்துக்காட்டைக் கவனியுங்கள்:
தொகுப்பு எடுரேகா பொது வகுப்பு ஜாவா ஆபரேட்டர்கள் {பொது நிலையான வெற்றிட மெயின் (சரம் [] ஆர்க்ஸ்) {int a = 58 System.out.println (a<>2) // வருமானம் 14 = 1110 System.out.println (ஒரு >>> 2) // வருமானம் 14}}இதன் மூலம், வெவ்வேறு ஜாவா ஆபரேட்டர்கள் குறித்த இந்த கட்டுரையின் முடிவுக்கு வருகிறோம். இந்த கட்டுரை உங்களுக்கு தகவலறிந்ததாக இருந்தது என்று நம்புகிறேன்.
பாருங்கள் உலகெங்கிலும் பரவியுள்ள 250,000 க்கும் மேற்பட்ட திருப்தியான கற்றவர்களின் வலைப்பின்னலுடன் நம்பகமான ஆன்லைன் கற்றல் நிறுவனமான எடுரேகாவால். உங்கள் பயணத்தின் ஒவ்வொரு அடியிலும் உங்களுக்கு உதவ நாங்கள் இங்கு வந்துள்ளோம், இந்த ஜாவா நேர்காணல் கேள்விகளைத் தவிர்த்து, ஜாவா டெவலப்பராக விரும்பும் மாணவர்கள் மற்றும் நிபுணர்களுக்காக வடிவமைக்கப்பட்ட ஒரு பாடத்திட்டத்தை நாங்கள் கொண்டு வருகிறோம்.
எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? தயவுசெய்து இந்த “ஜாவாவில் ஆபரேட்டர்கள்” கட்டுரையின் கருத்துகள் பிரிவில் குறிப்பிடவும், விரைவில் நாங்கள் உங்களைத் தொடர்புகொள்வோம்.