ஆபரேட்டர் முன்னுரிமை - 1

"வணக்கம், பிலாபோ!"

"பிலாபோ தனது நண்பரை வாழ்த்துவதில் மகிழ்ச்சி!"

"இன்று பிலாபோ ஆபரேட்டர் முன்னுரிமையைப் பற்றி உங்களுக்குச் சொல்வார். ஆனால் முதலில் அவர் ஆபரேட்டர்களைப் பற்றி உங்களுக்குச் சொல்வார்."

"இந்த ஆபரேட்டர்கள் பற்றி நீங்கள் என்ன சொல்கிறீர்கள்?"

"உண்மையில், நீங்கள் அவர்களை ஏற்கனவே அறிந்திருக்கிறீர்கள். அவர்கள் ஆபரேட்டர்கள் என்று அழைக்கப்படுவதை நீங்கள் அறிந்திருக்க வாய்ப்பில்லை."

"உதாரணமாக, எங்களிடம்  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 என்பது ஒற்றைப்படையா என்பதை நீங்கள் சரிபார்க்க வேண்டும் என்றால், நீங்கள் எழுதலாம்:"

Java webinar 
if (b % 2 == 1)

"அல்லது d 3 ஆல் வகுபடுமா என்பதைச் சரிபார்க்க:"

if (d % 3 == 0)

"சுவாரஸ்யமாக இருக்கிறது, நான் அதை நினைவில் கொள்கிறேன்."

2)  " ஒப்பீடு ஆபரேட்டர்கள் "

சின்னம் உதாரணமாக பெயர் விளக்கம் (அது என்ன செய்கிறது)
< a < b விட குறைவாக a ஐ விட குறைவாக உள்ளதா என சரிபார்க்கிறது.
<= c <= d குறைவாக அல்லது சமமாக c என்பது d ஐ விட குறைவாக உள்ளதா அல்லது சமமாக உள்ளதா என்பதை சரிபார்க்கிறது.
> a > b விட பெரியது a ஐ விட அதிகமாக உள்ளதா என சரிபார்க்கிறது.
>= c >= d இதை விட பெரியது அல்லது சமமானது c என்பது d ஐ விட அதிகமாக உள்ளதா அல்லது சமமாக உள்ளதா என்பதை சரிபார்க்கிறது.
== i == j சமம் நான் 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 அல்லது பிட்வைஸ் அல்லது
~ ~a இல்லை பிட்வைஸ் இல்லை
^ a ^ b XOR பிட்வைஸ் "எக்ஸ்க்ளூசிவ் அல்லது"

" பிட்வைஸ் ஆபரேட்டர்கள் முழு எண்களில் பிட்-பை-பிட் செயல்பாடுகளைச் செய்கிறார்கள்."

"என்ன அது?"

"ஒவ்வொரு எண்ணும் பிட்களின் தொகுப்பாகக் குறிப்பிடப்படுகிறது, பின்னர் முடிவு பின்வருமாறு கணக்கிடப்படுகிறது:"

"இரண்டு எண்களின் முதல் பிட் 1 ஆக இருந்தால், முடிவின் முதல் பிட் 1 ஆக இருக்கும்."

"இரண்டு எண்களின் இரண்டாவது பிட் 1 ஆக இருந்தால், முடிவின் இரண்டாவது பிட் 1 ஆக இருக்கும். மற்றும் பல."

"அனைத்து பிட்வைஸ் ஆபரேட்டர்களுக்கும் இது உண்மையா?"

"அதை விட இது மிகவும் எளிமையானது. ஒரு பிட் 0 மற்றும் 1 ஆகிய இரண்டு மதிப்புகளை மட்டுமே கொண்டிருக்க முடியும், இல்லையா?"

"சரி."

"பின்னர் 1 ஐ உண்மை என்றும், 0 தவறானது என்றும் எண்ணுங்கள். தனிப்பட்ட பிட்களின் செயல்பாடுகள் தருக்க செயல்பாடுகளுக்கு கிட்டத்தட்ட ஒரே மாதிரியாக இருக்கும்:"

தர்க்கரீதியான வெளிப்பாடு பிட்வைஸ் வெளிப்பாடு
உண்மை && உண்மை == உண்மை 1&1 == 1
உண்மை && பொய் == பொய் 1&0 == 0
உண்மை || உண்மை == உண்மை 1|1 == 1
உண்மை || பொய் == உண்மை 1|0 == 1
பொய் || பொய் = பொய் 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;
=
*=, /=, %=
-=, +=
<<=. >>=, >>>=
&=, ^=. |=
குறைந்த முன்னுரிமை (கடைசியாக நிகழ்த்தப்பட்டது)