Course जावा मल्टीथ्रेडिंग - Lecture: ऑपरेटर प्राधान्य

"हाय, बिलाबो!"

"बिलाबोला त्याच्या मित्राला अभिवादन करण्यात आनंद झाला!"

"आज बिलाबो तुम्हाला ऑपरेटरच्या प्राधान्याबद्दल सांगेल. पण आधी तो तुम्हाला स्वतः ऑपरेटरबद्दल सांगेल."

"तुम्ही कोणत्या ऑपरेटरबद्दल बोलत आहात?"

"खरं तर, तुम्ही त्यांच्याशी आधीच परिचित आहात. तुम्हाला कदाचित माहित नसेल की त्यांना ऑपरेटर म्हणतात."

"उदाहरणार्थ, म्हणा की आमच्याकडे c = a + b; "

"यात दोन ऑपरेटर आहेत: एक अतिरिक्त ऑपरेटर आणि एक असाइनमेंट ऑपरेटर."

"दुसर्‍या शब्दात, ऑपरेटर फक्त गणिती चिन्हे आहेत? जसे गुणाकार, भागाकार आणि बेरीज?"

"हो, ते खरे आहे. तथापि, मतभेद आहेत."

"मी तुमच्यासाठी ऑपरेटर परिभाषित करणार नाही: एक व्याख्या तुम्हाला हुशार बनवणार नाही. त्यांना कृती करताना पाहणे चांगले आहे. ऑपरेटर अनेक गटांमध्ये विभागले जाऊ शकतात, ज्याचे आम्ही आता परीक्षण करू."

1) " गणितीय ऑपरेटर "

चिन्ह	उदाहरण	नाव	वर्णन (ते काय करते)
`+`	`a + b`	अॅडिशन ऑपरेटर	अॅडिशन ऑपरेटर.
`-`	`c - d`	वजाबाकी ऑपरेटर	पहिल्या मधून दुसरी संख्या वजा करते.
`*`	`a * t`	गुणाकार ऑपरेटर	दोन संख्यांचा गुणाकार करतो.
`/`	`a / b`	विभाग ऑपरेटर	पहिल्या संख्येला दुसऱ्याने भागतो.
`%`	`c % d`	पहिल्या संख्येला दुसऱ्याने भागतो.	पहिल्या संख्येला दुसऱ्याने भागल्यानंतर उर्वरित मोजतो.
`-`	`-a`	युनरी वजा	व्हेरिएबलचे चिन्ह त्याच्या विरुद्ध बदलते. अधिक ते वजा, आणि वजा ते अधिक.
`+`	`+a`	युनरी प्लस	काहीही बदलत नाही. युनरी मायनस ऑपरेटरची प्रशंसा करण्यासाठी हे जोडले गेले. हे फक्त दिसण्यासाठी आहे.

"मी हे शाळेतून ओळखतो. माझ्या फर्मवेअरमध्ये शालेय अभ्यासक्रमांचा समावेश होतो."

"पण, त्या टक्के चिन्हाचे काय आहे, काही प्रकारचे जादूगार?"

"हा " भागाकारानंतरचा उरलेला भाग " ऑपरेटर आहे. जर 11 ला 5 ने भागले तर आपल्याला 2 आणि उर्वरित 1 मिळेल. हा 1 11 % 5 लिहून मिळू शकतो;"

"जेव्हा तुम्ही Java मध्‍ये पूर्णांकांना विभाजित करता, तेव्हा परिणाम देखील पूर्णांक असतो. भागाकार ऑपरेशनमधील उरलेल्या भागाकडे दुर्लक्ष केले जाते. जर आपण 8 ला 5 ने भागले तर आपल्याला 1 मिळेल."

अभिव्यक्ती	परिणाम
`19 / 10`	१	जर आपण 19 ला 10 ने भागले तर 9 च्या उरलेल्या परिणामासह 1 येईल .
`19 % 10`	९	जर आपण 19 ला 10 ने भागले तर 9 च्या उरलेल्या परिणामासह 1 येईल .
`2 / 5`	0	जर आपण 2 ला 5 ने भागले तर 2 च्या उरलेल्या भागासह परिणाम 0 असेल.
`16 % 2`	0	जर आपण 16 ला 2 ने भागले तर 0 च्या उरलेल्या परिणामासह 8 येतो .

"पण जगात आपल्याला बाकी कशाची गरज आहे?"

"समजा तुम्हाला पूर्णांक सम आहे की नाही हे तपासायचे आहे. मग तुम्ही लिहू शकता:"

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 शून्याच्या बरोबरीचे नाही हे पाहण्यासाठी तपासते.

"मी हे सर्व आधीच वापरतो."

"आणि या ऑपरेटर आणि गणितीय ऑपरेटरमध्ये मुख्य फरक काय आहे?"

"जर आपण दोन संख्या जोडल्या तर आपल्याला एक संख्या मिळेल; परंतु, जर आपण दोन संख्यांची तुलना केली तर आपल्याला सत्य किंवा खोटे मिळेल."

"हे बरोबर आहे. तुलनेचा परिणाम म्हणजे " लॉजिकल व्हॅल्यू " व्हॅल्यू, जे तुम्हाला माहीत आहे, बुलियन प्रकाराने दर्शविले जाते. दोन शक्यता आहेत: खरे किंवा असत्य.

"हो, हे सर्व स्पष्ट आहे. मला ते आधीच माहित आहे."

३) " लॉजिकल ऑपरेटर "

चिन्ह	उदाहरण	नाव	वर्णन (ते काय करते)
`&&`	`a && b`	आणि	जेव्हा a आणि b दोन्ही सत्य असतात तेव्हाच अभिव्यक्तीचा परिणाम सत्य असतो.
`\|\|`	`c \|\| d`	किंवा	a किंवा b सत्य असल्यास अभिव्यक्तीचा परिणाम सत्य आहे. ते दोन्ही किंवा किमान एक.
`!`	`!a`	नाही	a असत्य असेल तरच अभिव्यक्तीचा परिणाम खरा असेल.

"लॉजिकल ऑपरेटर फक्त बुलियन व्हेरिएबल्स किंवा एक्सप्रेशन्ससह वापरले जाऊ शकतात."

उदाहरण	वर्णन
`boolean a = true;` `boolean b = true;if (a && b)`	जर दोन्ही मूल्ये सत्य असतील तर if अट सत्य आहे दुसऱ्या शब्दांत, a आणि b दोन्ही सत्य असल्यास, परिणाम सत्य आहे .
`boolean a = true;` `boolean b = false;if (a \|\| b)`	जर किमान एक मूल्य सत्य असेल तर if स्थिती सत्य आहे , दुसऱ्या शब्दांत, 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 हे पूर्णांक आहेत, परंतु पूर्णांकांची तुलना केल्याचे परिणाम तार्किक मूल्य (सत्य, असत्य) आहे, याचा अर्थ आपण लॉजिकल ऑपरेटर वापरू शकतो.

"मला हे सर्व आधीच माहित आहे."

"खरंच? चला मग पुढे जाऊया."

४) " बिटवाइज ऑपरेटर "

चिन्ह	उदाहरण	नाव	वर्णन (ते काय करते)
`&`	`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	१
`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`	~ ००००१००१	11110110	२४६

"धन्यवाद, बिलाबो. आता मला कळले."

"बिटवाइज ऑपरेटर्सचा आणखी एक गट आहे, शिफ्ट ऑपरेटर:"

५) " शिफ्ट ऑपरेटर "

चिन्ह	उदाहरण	नाव	वर्णन (ते काय करते)
`>>`	`a >> b`	उजवीकडे शिफ्ट	a अंकाचे बिट b अंकांनी उजवीकडे हलवते.
`<<`	`c << d`	डावी शिफ्ट	c क्रमांकाचे बिट d अंकांनी डावीकडे हलवते.
`>>>`	`a >>> 2`	सही न केलेली उजवी शिफ्ट	a क्रमांकाचे बिट 2 अंकांनी उजवीकडे हलवते.

"ही कसली रस्त्यावरची जादू आहे?"

"हे सर्व खरोखर सोपे आहे. ते पहा:"

उदाहरण	बिट्स म्हणून संख्या	बिट्स म्हणून परिणाम	परिणाम
`10 >> 1`	0000 101 0 >> 1	00000 101	५
`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	ऋण संख्या ऋणच राहते. ऋण संख्यांसाठी, येणारे बिट्स 1s ने भरलेले आहेत.
1 000 1010 >> 2	111 000 10
1 000 1010 >> 3	1111 000 1
1 000 1010 >>> १	01 000 101	ऋण संख्या यापुढे ऋण नाही. ऋण संख्यांसाठी, येणारे बिट्स 0s ने भरलेले असतात.
1 000 1010 >>> 2	001 000 10
1 000 1010 >>> 3	0001 000 1

"शिफ्ट चक्रीय नाही. संख्येच्या डाव्या किंवा उजव्या काठाच्या पलीकडे जाणारे बिट्स फक्त टाकून दिले जातात."

६) " असाईनमेंट ऑपरेटर "

"असाईनमेंट म्हणजे काय हे मला आधीच माहीत आहे. पण तुम्ही 'ऑपरेटर' का म्हणता?"

"कारण त्यापैकी बरेच आहेत ☺"

ऑपरेटर	म्हणजे काय
`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;`

"मला वाटतं तुला तर्क समजला."

७) " इन्क्रीमेंट आणि डिक्रिमेंट ऑपरेटर "

नोटेशन	उदाहरण	वर्णन
`++`	`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;`

"बरं, ते खूप सोयीस्कर आहे."

"होय. आणि तो कॉम्पॅक्ट आहे आणि कोड वाचनीय आहे. त्याचा वापर करून आनंद घ्या!"

९) " इतर "

"तुमचा संगीत संग्रह कितीही व्यवस्थित असला तरीही, तुम्हाला "विविध" फोल्डर तयार करावे लागेल."

"होय, ज्याला कधीही संगीताचे वर्गीकरण करावे लागले ते पूर्णपणे सहमत असेल."

"म्हणून, आणखी तीन ऑपरेटर आहेत ज्यांच्याबद्दल मला तुम्हाला सांगायचे आहे:"

नोटेशन	उदाहरण	वर्णन
`()`	`(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;`
`=` `*=, /=, %=` `-=, +=` `<<=. >>=, >>>=` `&=, ^=. \|=`
सर्वात कमी प्राधान्य (शेवटचे केले)