बूलियन ऑपरेटरों में अंतर: और बनाम && और | बनाम ||

Question

मुझे नियमों के बारे में पता है &&और ||क्या हैं &और क्या हैं |? कृपया मुझे एक उदाहरण के साथ इनकी व्याख्या करें।

Answer 1

वे बिटवाइज़ और बिटवाइज़ या ऑपरेटर्स हैं।

int a = 6; // 110
int b = 4; // 100

// Bitwise AND    

int c = a & b;
//   110
// & 100
// -----
//   100

// Bitwise OR

int d = a | b;
//   110
// | 100
// -----
//   110

System.out.println(c); // 4
System.out.println(d); // 6

अपने इनपुट्स के आधार पर ऑपरेटर के विभिन्न व्यवहारों के बारे में जावा लैंग्वेज स्पेस ( 15.22.1 , 15.22.2 ) में उपयुक्त अनुभाग को इंगित करने के लिए कार्लोस का धन्यवाद ।

वास्तव में जब दोनों इनपुट बूलियन होते हैं, तो ऑपरेटर को बूलियन लॉजिकल ऑपरेटर्स माना जाता है और यह सशर्त-और ( &&) और सशर्त-या ( ||) ऑपरेटरों के समान व्यवहार करता है, केवल इस तथ्य को छोड़कर कि वे शॉर्ट-सर्किट नहीं करते हैं ताकि निम्नलिखित सुरक्षित रहे :

if((a != null) && (a.something == 3)){
}

यह नहीं है:

if((a != null) & (a.something == 3)){
}

"शॉर्ट-सर्किटिंग" का अर्थ है कि ऑपरेटर आवश्यक रूप से सभी स्थितियों की जांच नहीं करता है। उपरोक्त उदाहरण में, &&दूसरी शर्त की जांच करेंगे केवल जब aनहीं है null(अन्यथा पूरे बयान अवास्तविक लौटाते हैं, और यह वैसे भी निम्न स्थितियों में जांच करने के लिए विवादास्पद हो जाएगा), तो के बयान a.somethingएक अपवाद से आगे नहीं बढ़ेगी, या "सुरक्षित माना जाता है । "

&ऑपरेटर हमेशा खंड में हर हालत की जांच करता है, तो ऊपर के उदाहरण में, a.somethingमूल्यांकन किया जा सकता है जब aएक वास्तव में nullमूल्य, एक अपवाद को ऊपर उठाने।

Comments

स्पष्ट करना चाहता था .. और केवल 1 वापस करेगा यदि दोनों 1 हैं? तो 101 और 001 001 होगा? सही?

— गिदोन

@giddy @Jonathon - मैंने उस स्थिति को बेहतर दिखाने के लिए अपने मूल्यों को अद्यतन किया।

— जस्टिन निस्नेर

अपूर्ण: वे लॉजिकल ऑपरेटर (बूलियन के लिए) भी हैं।

— user85421

@ कार्लोस- नहीं। वे अभी भी बिटवाइज़ ऑपरेटर हैं। वे सिर्फ गैर-शॉर्ट सर्कुलेटिंग लॉजिकल ऑपरेटर्स के समान व्यवहार करते हैं। इसमे अंतर है।

— जस्टिन नेस्नर

और गैर-शॉर्ट सर्कुलेटिंग लॉजिकल ऑपरेटर्स क्या हैं? संचालक और | (ओपी द्वारा पूछा गया) "इंटेगर बिटवाइज ऑपरेटर्स" (JLS 15.22.1) और "बुलियन लॉजिकल ऑपरेटर्स" (JLS 15.22.2) हैं। या जावा लैंग्वेज स्पेसिफिकेशन उसके बारे में गलत है?

— user85421

Answer 2

मुझे लगता है कि आप दोनों ऑपरेटरों के तार्किक अर्थ के बारे में बात कर रहे हैं, यहाँ आपके पास एक टेबल-रिज्यूम है:

boolean a, b;

Operation     Meaning                       Note
---------     -------                       ----
   a && b     logical AND                    short-circuiting
   a || b     logical OR                     short-circuiting
   a &  b     boolean logical AND            not short-circuiting
   a |  b     boolean logical OR             not short-circuiting
   a ^  b     boolean logical exclusive OR
  !a          logical NOT

short-circuiting        (x != 0) && (1/x > 1)   SAFE
not short-circuiting    (x != 0) &  (1/x > 1)   NOT SAFE

शॉर्ट-सर्किट मूल्यांकन , न्यूनतम मूल्यांकन, या मैक्कार्थी मूल्यांकन (जॉन मैकार्थी के बाद) कुछ प्रोग्रामिंग भाषाओं में कुछ बूलियन ऑपरेटरों का शब्दार्थ है जिसमें दूसरे तर्क का निष्पादन या मूल्यांकन केवल तभी किया जाता है जब पहले तर्क का मान निर्धारित करने के लिए पर्याप्त नहीं है। अभिव्यक्ति: जब AND फ़ंक्शन का पहला तर्क गलत का मूल्यांकन करता है, तो समग्र मान गलत होना चाहिए; और जब OR फ़ंक्शन का पहला तर्क सत्य का मूल्यांकन करता है, तो समग्र मान सत्य होना चाहिए।

सुरक्षित नहीं होने का अर्थ है कि ऑपरेटर हमेशा क्लॉज में हर स्थिति की जांच करता है, इसलिए ऊपर दिए गए उदाहरणों में, 1 / x का मूल्यांकन तब किया जा सकता है जब एक्स वास्तव में, 0 मान हो, एक अपवाद को बढ़ाते हुए।

Comments

@Torres - कृपया "लघु परिशोधन" और "सुरक्षित" समझाकर अपने उत्तर का विस्तार करें। "एक्सक्लूसिव या" और "लॉजिकल नॉट" भी "शॉर्ट-सर्कुलेटिंग नहीं" है? और इसे "बूलियन लॉजिकल नॉट" के बजाय "लॉजिकल नॉट" क्यों कहा जाता है? और "लॉजिकल नॉट" को "लॉजिकल एंड" और "लॉजिकल ऑर" के साथ क्यों नहीं जोड़ा गया है? अच्छा जवाब लेकिन काम चाहिए।

— tfmontague

@tfmontague, मैंने बताया है कि शॉर्ट सर्किटिंग का क्या मतलब है (इस उत्तर को संपादित करके) .. मेरे संपादन की प्रतीक्षा "सहकर्मी की समीक्षा" के लिए की जा रही है।

— तस्लीम ओसेनी

शॉर्ट-सर्किटिंग के बारे में "असुरक्षित" क्या है? क्या यह शॉर्ट-सर्किट का उपयोग करने से अधिक सुरक्षित नहीं होना चाहिए? btw: आप वास्तव में "शॉर्ट-सर्किट" शब्द की व्याख्या नहीं करते हैं। इसका मतलब है कि "शॉर्ट-सर्किट नहीं" पर सभी भागों का पहले मूल्यांकन किया जाता है, फिर बूलियन ऑपरेशन को लागू किया जाता है, जबकि शॉर्ट-सर्किट पर मूल्यांकन बंद कर दिया जाता है, जब पहली अभिव्यक्ति स्थिति को संतुष्ट करती है, जैसे (एक || बी) नहीं होगा b का मूल्यांकन करें, यदि कोई सत्य है और ऑपरेशन सही है, तो कोई भी बात नहीं है।

— SCI

Answer 3

मुझे पता है कि यहां बहुत सारे उत्तर हैं, लेकिन वे सभी थोड़े भ्रमित हैं। इसलिए जावा ओरेकल अध्ययन गाइड से कुछ शोध करने के बाद, मैं तीन अलग-अलग परिदृश्यों के साथ आया हूं, जब उपयोग करने के लिए && या &। तीन परिदृश्य तार्किक और , बिटवाइंड और बूलियन हैं ।

तार्किक और: तार्किक और (उर्फ सशर्त और) && ऑपरेटर का उपयोग करता है । यह छोटा-परिचालित अर्थ है: यदि बाएं ऑपरेंड झूठा है, तो सही ऑपरेंड का मूल्यांकन नहीं किया जाएगा।
उदाहरण:

int x = 0;
if (false && (1 == ++x) {
    System.out.println("Inside of if");
}
System.out.println(x); // "0"

उपरोक्त उदाहरण में x के कंसोल पर मुद्रित मूल्य 0 होगा, क्योंकि यदि कथन में पहला ऑपरेंड गलत है, इसलिए जावा को गणना करने की कोई आवश्यकता नहीं है (1 == ++ x) इसलिए x की गणना नहीं की जाएगी।

Bitwise और: Bitwise और & ऑपरेटर का उपयोग करता है । इसका उपयोग मूल्य पर एक बिटवाइज़ ऑपरेशन को सुधारने के लिए किया जाता है। यह देखना बहुत आसान है कि बाइनरी नंबरों पर ऑपरेशन को देखकर क्या हो रहा है:

int a = 5;     //                    5 in binary is 0101
int b = 12;    //                   12 in binary is 1100
int c = a & b; // bitwise & preformed on a and b is 0100 which is 4

जैसा कि आप उदाहरण में देख सकते हैं, जब संख्या 5 और 12 के द्विआधारी निरूपण को पंक्तिबद्ध किया जाता है, तो एक बिटवाइज़ और प्रीफ़र्ड केवल एक बाइनरी संख्या का उत्पादन करेगा जहाँ दोनों संख्याओं में एक ही अंक 1 होता है। इसलिए 0101 और 1100 == 0100. जो दशमलव में 5 और 12 == 4 है।

बूलियन और: अब बूलियन और ऑपरेटर बिटवाइंड और तार्किक और दोनों के लिए समान और अलग तरीके से व्यवहार करता है। मैं इसे एक बिट वाइज और दो बूलियन मानों (या बिट्स) के बीच के रूप में सोचना पसंद करता हूं, इसलिए यह & ऑपरेटर का उपयोग करता है । बूलियन मूल्य एक तार्किक अभिव्यक्ति का परिणाम भी हो सकता है।

यह या तो एक वास्तविक या गलत मान देता है, तार्किक की तरह, लेकिन तार्किक के विपरीत और यह कम-परिचालित नहीं है। इसका कारण यह है कि, इसके लिए उस बिटवाइज़ को बेहतर बनाने के लिए, इसे बाएँ और दाएँ दोनों ऑपरेंड्स का मूल्य पता होना चाहिए। यहाँ एक पूर्व है:

int x = 0;
if (false & (1 == ++x) {
    System.out.println("Inside of if");
}
System.out.println(x); //"1"

अब जब कि यदि कथन को चलाया जाता है, तो अभिव्यक्ति (1 == ++ x) को निष्पादित किया जाएगा, भले ही बाएं ऑपरेंड झूठा हो। इसलिए x के लिए प्रिंट किया गया मान 1 होगा क्योंकि यह बढ़ा हुआ है।

यह तार्किक या (()), बिटवाइज़ OR (()) और बूलियन OR (!) पर भी लागू होता है। आशा है कि यह कुछ भ्रम को दूर करता है।

Comments

to preform that bitwise AND, it must know the value of both left and right operandsयह मुझे सही नहीं लगता। प्रदर्शन करने के लिए BITWISE ANDआपको सही ऑपरेंड को जानने की आवश्यकता नहीं है, यदि बाएं ऑपरेंड है तो परिणाम का पता लगाने में सक्षम होने के लिए FALSE। आप जो समझाते हैं वह सही है, लेकिन आप जो तर्क देते हैं, वह मुझे ऐसा नहीं लगता, कम से कम मेरे लिए ..

— कोरे तुगे

Answer 4

संचालक && और || शॉर्ट-सर्कुलेटिंग हैं, जिसका अर्थ है कि वे अपने दाहिने हाथ की अभिव्यक्ति का मूल्यांकन नहीं करेंगे यदि परिणाम को निर्धारित करने के लिए बाएं हाथ की अभिव्यक्ति का मूल्य पर्याप्त है।

Comments

-1 ओपी को यह बताने के लिए कि वह पहले से जानता था और उस सवाल का जवाब नहीं दे रहा था जो उसने पूछा था।

— अलनीतक

Answer 5

और | && और || के समान परिणाम प्रदान करें ऑपरेटरों। अंतर यह है कि वे हमेशा अभिव्यक्ति के दोनों पक्षों का मूल्यांकन करते हैं, जहां && और || यदि परिणाम निर्धारित करने के लिए पहली शर्त पर्याप्त है तो मूल्यांकन करना बंद कर दें।

Comments

गलत .... इसके &&लिए दोनों परिणामों का मूल्यांकन करता है, जबकि ||केवल पहली शर्त सही होने पर ही रिटर्न देता है।

— बुहके सिंडी

है ना? && केवल दाएं हाथ की अभिव्यक्ति का मूल्यांकन करता है यदि बाएं हाथ की ओर पहले से ही सच का मूल्यांकन करता है। अन्यथा इसका मूल्यांकन करना बंद हो जाता है क्योंकि पहला गलत अर्थ है कि परिणाम सही नहीं हो सकता है। Jguru.com/faq/view.jsp?EID=16530

— ब्रायन स्कॉट

( 2 & 4 )मूल्यांकन करता है false, जबकि ( 2 && 4 )मूल्यांकन करता है true। वास्तव में यह कैसा है?

— पिस्कोर ने

@Piskvor - जावा में नहीं! 2 & 4एक पूर्णांक में परिणाम, बूलियन नहीं (इस मामले में शून्य)। 2 && 4संकलन नहीं करेंगे, और& केवल बूलियन स्वीकार करते हैं। जावा बूलियन्स और falsefalse

— इनट्स को

@BuhakeSindi गलत। इसके लिए &&केवल दूसरे ऑपरेंड का मूल्यांकन करता है यदि पहला ऑपरेंड है true।

— लोर्ने का

Answer 6

जावा में, एकल संचालक और |;, ^,! ऑपरेंड पर निर्भर हैं। यदि दोनों ऑपरेंड्स इन्टस हैं, तो एक बिटवाइज़ ऑपरेशन किया जाता है। यदि दोनों बूलियन हैं, तो एक "तार्किक" ऑपरेशन किया जाता है।

यदि दोनों ऑपरेंड मिसमैच करते हैं, तो संकलन समय त्रुटि है।

डबल ऑपरेटर &&, || उनके एकल समकक्षों के समान व्यवहार करते हैं, लेकिन दोनों ऑपरेंड में सशर्त अभिव्यक्ति होनी चाहिए, उदाहरण के लिए:

अगर (एक <0) && (b <0)) {...} या इसी तरह, अगर ((एक <0) || (b <0)) {...} ||

स्रोत: जावा प्रोग्रामिंग लैंग 4 एड

Answer 7

&और |अभिन्न प्रकारों (जैसे int) पर बिटवाइज़ ऑपरेटर हैं : http://download.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

&&और ||केवल (और शॉर्ट-सर्किट पर बूलियनों पर काम करते हैं, जैसा कि अन्य उत्तर पहले ही कह चुके हैं)।

Comments

&और |बूलियन प्रकार पर बूलियन ऑपरेटर भी हैं।

— लोर्ने का

Answer 8

शायद यह जानना उपयोगी हो सकता है कि बिटवाइंड और बिटवाइज़ या ऑपरेटर्स हमेशा सशर्त और सशर्त या एक ही अभिव्यक्ति में उपयोग किए जाने से पहले मूल्यांकन किए जाते हैं।

if ( (1>2) && (2>1) | true) // false!

Comments

क्या आपका मतलब है कि मूल्यांकन की अपेक्षा ऑपरेटर प्राथमिकता है? मैं वास्तविक कोड में उपयोग किए गए प्राथमिकता अंतर को नहीं देखूंगा। इस उद्देश्य के लिए बिटवाइज़ ऑपरेटरों के बजाय कोष्ठकों का उपयोग करें।

— जॉन ड्वोरक

Answer 9

&&; || तार्किक ऑपरेटर हैं .... शॉर्ट सर्किट

&; | बूलियन लॉजिकल ऑपरेटर्स हैं .... नॉन-शॉर्ट सर्किट

अभिव्यक्ति पर अमल में अंतर के लिए आगे बढ़ रहा है। बिटवाइज़ ऑपरेटर बाएं हाथ की ओर के परिणाम के बावजूद दोनों पक्षों का मूल्यांकन करते हैं। लेकिन तार्किक ऑपरेटरों के साथ अभिव्यक्ति के मूल्यांकन के मामले में, दाएं हाथ की अभिव्यक्ति का मूल्यांकन बाएं हाथ की स्थिति पर निर्भर है।

उदाहरण के लिए:

int i = 25;
int j = 25;
if(i++ < 0 && j++ > 0)
    System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);

यह i = 26 प्रिंट करेगा; j = 25, जैसा कि पहली स्थिति झूठी है दाहिने हाथ की स्थिति को बायपास किया जाता है क्योंकि परिणाम सही हाथ की साइड कंडीशन के बावजूद गलत है। (शॉर्ट सर्किट)

int i = 25;
int j = 25;
if(i++ < 0 & j++ > 0)
    System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);

लेकिन, यह i = 26 प्रिंट करेगा; j = 26,

Answer 10

यदि बूलियन और ऑपरेटर से जुड़े एक अभिव्यक्ति का मूल्यांकन किया जाता है, तो दोनों ऑपरेंड का मूल्यांकन किया जाता है। फिर ऑपरेटर के लिए & ऑपरेटर लागू किया जाता है।

जब && ऑपरेटर से जुड़े एक अभिव्यक्ति का मूल्यांकन किया जाता है, तो पहले ऑपरेंड का मूल्यांकन किया जाता है। यदि पहला ऑपरेंड गलत का मूल्यांकन करता है, तो दूसरे ऑपरेंड का मूल्यांकन छोड़ दिया जाता है।

यदि पहला ऑपरेंड सही मान देता है तो दूसरे ऑपरेंड का मूल्यांकन किया जाता है। यदि दूसरा ऑपरेंड सही मान देता है तो && ऑपरेटर पहले और दूसरे ऑपरेंड पर लागू होता है।

इसके लिए समान | और ||

Answer 11

जबकि मूल अंतर यह है कि &ज्यादातर बिटकॉइन के संचालन के लिए उपयोग किया जाता है long, intया byteजहां इसे मास्क के प्रकार के लिए उपयोग किया जा सकता है, परिणाम तार्किक के बजाय इसका उपयोग करने पर भी भिन्न हो सकते हैं &&।

कुछ परिदृश्यों में अंतर अधिक ध्यान देने योग्य है:

1. कुछ भावों का मूल्यांकन समय लेने वाला है
2. किसी एक अभिव्यक्ति का मूल्यांकन केवल तभी किया जा सकता है, जब पिछले वाला सच था
3. भावों के कुछ साइड-इफेक्ट हैं (इरादा या नहीं)

पहला बिंदु काफी सीधा है, यह बग नहीं बनाता है, लेकिन इसमें अधिक समय लगता है। यदि आपके पास एक सशर्त बयानों में कई अलग-अलग चेक हैं, तो उन्हें डालें जो या तो सस्ते हैं या बाईं ओर विफल होने की संभावना है।

दूसरे बिंदु के लिए, इस उदाहरण को देखें:

if ((a != null) & (a.isEmpty()))

यह nullदूसरी अभिव्यक्ति के उत्पादन के मूल्यांकन के रूप में विफल रहता है NullPointerException। लॉजिकल ऑपरेटर &&आलसी है, यदि बाएं ऑपरेंड झूठा है, तो परिणाम गलत है कोई फर्क नहीं पड़ता कि सही ऑपरेंड क्या है।

तीसरे बिंदु के लिए उदाहरण - मान लीजिए कि हमारे पास एक ऐसा ऐप है जो बिना किसी ट्रिगर या कैस्केड के DB का उपयोग करता है। बिल्डिंग ऑब्जेक्ट को हटाने से पहले, हमें किसी डिपार्टमेंट ऑब्जेक्ट की बिल्डिंग को दूसरे में बदलना होगा। मान लें कि ऑपरेशन की स्थिति एक बूलियन (सच्ची = सफलता) के रूप में वापस आ गई है। फिर:

if (departmentDao.update(department, newBuilding) & buildingDao.remove(building))

यह दोनों अभिव्यक्तियों का मूल्यांकन करता है और इस प्रकार भवन निष्कासन करता है भले ही विभाग अपडेट किसी कारण से विफल हो गया हो। इसके साथ &&, यह इरादा के अनुसार काम करता है और यह पहली विफलता के बाद बंद हो जाता है।

के रूप में a || b, यह के बराबर है !(!a && !b), यह बंद हो जाता है अगर aसच है, कोई और अधिक स्पष्टीकरण की जरूरत है।