जावा में & && में क्या अंतर है?

Question

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

हाल ही में मुझे पता चला कि &ऑपरेटर को यह सत्यापित करने के लिए भी इस्तेमाल किया जा सकता है कि क्या उसके दोनों बूलियन ऑपरेंड हैं true, केवल अंतर यह है कि यह आरएचएस ऑपरेटर की जांच करता है, भले ही एलएचएस ऑपरेंड झूठा हो।

क्या &जावा में ऑपरेटर आंतरिक रूप से ओवरलोड है? या इसके पीछे कोई और अवधारणा है?

Comments

संभावित डुप्लिकेट क्यों हम आमतौर पर `` `` नहीं `` का उपयोग करते हैं, क्या अंतर है?

— ब्लेक यारब्रॉट

यदि संभव हो तो डबल शॉर्टकट करता है।

— निकोलस हैमिल्टन

Answer 1

& <- दोनों ऑपरेंड्स को सत्यापित करता है
&& <- मूल्यांकन करता है कि क्या पहला ऑपरेंड गलत के लिए मूल्यांकन करता है क्योंकि परिणाम गलत होगा

(x != 0) & (1/x > 1)<- इसका मतलब है मूल्यांकन करें (x != 0)फिर मूल्यांकन (1/x > 1)करें और फिर करें। समस्या यह है कि x = 0 के लिए यह एक अपवाद फेंक देगा।

(x != 0) && (1/x > 1)<- इसका मतलब है कि मूल्यांकन करें (x != 0)और केवल अगर यह सच है तो मूल्यांकन (1/x > 1)करें यदि आपके पास x = 0 है तो यह पूरी तरह से सुरक्षित है और कोई अपवाद नहीं फेंकेंगे यदि (x! 0) पूरी तरह से झूठी का मूल्यांकन करता है सीधे झूठ का मूल्यांकन करता है मूल्यांकन के बिना (1/x > 1)।

संपादित करें:

exprA | exprB<- इसका अर्थ है मूल्यांकन करें exprAफिर मूल्यांकन exprBकरें |।

exprA || exprB<- इसका अर्थ है मूल्यांकन करना exprAऔर केवल अगर यह है falseतो मूल्यांकन करें exprBऔर करें ||।

Comments

एक और लिखने का क्या कारण है? अगर बयान में यह कभी भी && से तेज नहीं होगा और || यदि हम पहले से ही उत्तर दे सकते हैं तो हम दूसरी स्थिति क्यों जांचना चाहते हैं? आप प्रदान कर सकते हैं और यथार्थवादी उदाहरण, कृपया?

— मिकूका93

@ Michu93: एक उदाहरण यह होगा कि यदि दूसरी स्थिति एक फ़ंक्शन कॉल है जिसका साइड इफेक्ट है जो आपको हमेशा चाहिए। चूंकि साइड इफेक्ट्स आमतौर पर बचा जाना चाहिए, केवल दुर्लभ मामले होंगे जहां आपको इसकी आवश्यकता होती है, और मैं इस समय एक यथार्थवादी उदाहरण के बारे में नहीं सोच सकता।

— हिनजी

Answer 2

दोनों ऑपरेंड्स का मूल्यांकन करके एक आलसी मूल्यांकनकर्ता नहीं होने के अलावा, मुझे लगता है कि बिटवाइज़ ऑपरेटरों की मुख्य विशेषताओं में निम्नलिखित उदाहरण में ऑपरेंड के प्रत्येक बाइट्स की तुलना करें:

int a = 4;
int b = 7;
System.out.println(a & b); // prints 4
//meaning in an 32 bit system
// 00000000 00000000 00000000 00000100
// 00000000 00000000 00000000 00000111
// ===================================
// 00000000 00000000 00000000 00000100

Comments

सवाल तार्किक बूलियन ऑपरेशनों के बारे में है, न कि बिटवाइज़ ऑपरेशंस के बारे में।

— लोर्न

@ ईजेपी यह अभी भी मेरे जैसे गुगलों को मदद करता है, जो केवल शीर्षक पढ़ते हैं।

— विज्ञापन Infinitum

Answer 3

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

Comments

धन्यवाद एंड्रियास को संपादित करने के लिए, शायद यह अन्य प्रश्न भी मदद करता है: stackoverflow.com/questions/4014535/vs-and-vs

— Torres

Answer 4

यह तर्कों के प्रकार पर निर्भर करता है ...

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

बूलियन तर्कों के लिए, एकल एम्परसेंड का गठन (बिना शर्त) "तार्किक और" ऑपरेटर होता है, जबकि डबल एम्परसेंड ("&&") "सशर्त तार्किक और" ऑपरेटर होता है। कहने का तात्पर्य यह है कि सिंगल एम्पर्सैंड हमेशा दोनों तर्कों का मूल्यांकन करता है जबकि डबल एम्परसेंड केवल दूसरे तर्क का मूल्यांकन करेगा यदि पहला तर्क सत्य है।

अन्य सभी प्रकार के तर्क और संयोजनों के लिए, एक संकलन-समय त्रुटि होनी चाहिए।

Answer 5

&& एक शॉर्ट सर्किट ऑपरेटर है और & AND ऑपरेटर है।

इसे इस्तेमाल करे।

    String s = null;
    boolean b = false & s.isEmpty(); // NullPointerException
    boolean sb = false && s.isEmpty(); // sb is false

Answer 6

यह जेएलएस (15.22.2) में निर्दिष्ट है :

जब दोनों के a, ^, या | ऑपरेटर प्रकार बूलियन या बूलियन के होते हैं, फिर बिटवाइज ऑपरेटर अभिव्यक्ति का प्रकार बूलियन होता है। सभी मामलों में, ऑपरेंड आवश्यक के रूप में अनबॉक्सिंग रूपांतरण (.85.1.8) के अधीन हैं।

& के लिए, परिणाम मान सत्य है यदि दोनों ऑपरेंड मान सत्य हैं; अन्यथा, परिणाम गलत है।

^ के लिए, परिणाम मान सही है यदि ऑपरेंड मान भिन्न हैं; अन्यथा, परिणाम गलत है।

के लिए: परिणाम मान गलत है यदि दोनों ऑपरेंड मान गलत हैं; अन्यथा, परिणाम सच है।

"ट्रिक" वह &है जो एक इंटेगर बिटवाइज़ ऑपरेटर के साथ-साथ बूलियन लॉजिकल ऑपरेटर भी है । तो क्यों नहीं, इसे ऑपरेटर ओवरलोडिंग के लिए एक उदाहरण के रूप में देखना उचित है।

Answer 7

मुझे लगता है कि मेरा उत्तर अधिक समझने योग्य हो सकता है:

के बीच दो अंतर हैं &और &&।

यदि वे तार्किक और के रूप में उपयोग करते हैं

&और &&तार्किक हो सकता है AND, जब &या &&बाएँ और दाएँ अभिव्यक्ति परिणाम सब सच है, पूरे ऑपरेशन परिणाम सच हो सकता है।

जब &और &&जैसे तार्किक AND, एक अंतर है:

जब &&तार्किक रूप में उपयोग किया जाता है AND, यदि बाईं अभिव्यक्ति का परिणाम गलत है, तो सही अभिव्यक्ति निष्पादित नहीं होगी।

उदाहरण लें:

String str = null;

if(str!=null && !str.equals("")){  // the right expression will not execute

}

यदि उपयोग कर रहे हैं &:

String str = null;

if(str!=null & !str.equals("")){  // the right expression will execute, and throw the NullPointerException 

}

एक और अधिक उदाहरण:

int x = 0;
int y = 2;
if(x==0 & ++y>2){
    System.out.print(“y=”+y);  // print is: y=3
}

---

int x = 0;
int y = 2;
if(x==0 && ++y>2){
    System.out.print(“y=”+y);  // print is: y=2
}

और बिट ऑपरेटर के रूप में इस्तेमाल किया जा सकता है

&Bitwise ANDऑपरेटर के रूप में इस्तेमाल किया जा सकता है , &&नहीं।

बिटवाइज़ और "&" ऑपरेटर 1 उत्पन्न करता है और यदि उसके दोनों बिट्स केवल तभी काम करते हैं तो 1. हालांकि, यदि दोनों बिट्स 0 हैं या दोनों बिट्स अलग-अलग हैं तो यह ऑपरेटर 0. पैदा करता है। अधिक सटीक बिटवाइज़ होने के लिए और "&" ऑपरेटर 1 लौटाता है यदि दो बिट्स में से कोई 1 है और यह 0 रिटर्न है यदि कोई बिट्स 0 है। 

विकी पेज से:

http://www.roseindia.net/java/master-java/java-bitwise-and.shtml

Answer 8

'&&': - एक लॉजिकल एंड ऑपरेटर अपने तर्कों के तार्किक संबंध के आधार पर सही या गलत के बूलियन मूल्य का उत्पादन करता है।

उदाहरण के लिए: - Condition1 && Condition2

यदि Condition1 गलत है, तो (Condition1 && Condition2) हमेशा गलत होगा, यही कारण है कि इस तार्किक ऑपरेटर को शॉर्ट सर्किट ऑपरेटर के रूप में भी जाना जाता है क्योंकि यह किसी अन्य स्थिति का मूल्यांकन नहीं करता है। यदि कंडीशन 1 गलत है, तो Condtiton2 का मूल्यांकन करने की आवश्यकता नहीं है।

अगर कंडीशन 1 सच है, तो कंडीशन 2 का मूल्यांकन किया जाता है, अगर यह सच है तो कुल मिलाकर परिणाम सही होगा अन्यथा यह गलत होगा।

'और': - एक बिटवाइज़ और ऑपरेटर है। यह आउटपुट में एक (1) उत्पन्न करता है यदि दोनों इनपुट बिट्स एक हैं। अन्यथा यह शून्य (0) का उत्पादन करता है।

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

int a = 12; // 12 का बाइनरी प्रतिनिधित्व 1100 है

int b = 6; // 6 का बाइनरी प्रतिनिधित्व 0110 है

int c = (a & b); // (12 और 6) का बाइनरी प्रतिनिधित्व 0100 है

C का मान 4 है।

संदर्भ के लिए, इस http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html देखें

Answer 9

&&और ||शॉर्ट सर्किट ऑपरेटर कहलाते हैं। जब उनका उपयोग किया जाता है, ||तो - यदि पहले ऑपरेंड का मूल्यांकन किया जाता है true, तो बाकी ऑपरेंड का मूल्यांकन नहीं किया जाता है। के लिए &&- यदि पहला ऑपरेंड मूल्यांकन करता है false, तो उनमें से बाकी का मूल्यांकन बिल्कुल नहीं किया जाता है।

इसलिए if (a || (++x > 0))इस उदाहरण में अगर एक था चर x वृद्धि नहीं किया जाएगा true।

Answer 10

बूलियन के साथ, दोनों के बीच कोई आउटपुट अंतर नहीं है। आप स्वैप कर सकते हैं && और & या || और | और यह आपकी अभिव्यक्ति के परिणाम को कभी नहीं बदलेगा।

अंतर उस दृश्य के पीछे है जहां सूचना संसाधित की जा रही है। जब आप एक अभिव्यक्ति को सही करते हैं "(ए! = 0) और (बी! = 0)" के लिए = 0 और बी = 1 के लिए, निम्न कार्य करते हैं:

left side: a != 0 --> false
right side: b 1= 0 --> true
left side and right side are both true? --> false
expression returns false

जब आप एक अभिव्यक्ति लिखते हैं (a != 0) && ( b != 0)जब a = 0 और b = 1, निम्न होता है:

a != 0 -->false
expression returns false

कम कदम, कम प्रसंस्करण, बेहतर कोडिंग, विशेष रूप से कई बूलियन अभिव्यक्ति या जटिल तर्क करते समय।

Comments

यह अभिव्यक्ति के समग्र परिणाम को बदल देगा यदि ऑपरेंड के दुष्प्रभाव हैं।

— लोर्न

Answer 11

इसके अलावा और& और || शॉर्ट सर्किटिंग होने के कारण, दोनों रूपों को मिलाते समय ऑपरेटर पूर्वता पर भी विचार करें। मुझे लगता है कि यह हर किसी के लिए तुरंत स्पष्ट नहीं होगा कि result1 और result2 में अलग-अलग मूल्य हैं।

boolean a = true;
boolean b = false;
boolean c = false;

boolean result1 = a || b && c; //is true;  evaluated as a || (b && c)
boolean result2 = a  | b && c; //is false; evaluated as (a | b) && c

Answer 12

& दोनों स्थितियों की जाँच के लिए बिटवाइट ऑपरेटर प्लस का उपयोग किया जाता है क्योंकि कभी-कभी हमें दोनों स्थितियों का मूल्यांकन करने की आवश्यकता होती है। लेकिन && तार्किक ऑपरेटर दूसरी स्थिति में जाता है जब पहली शर्त सच होती है।

Answer 13

सभी उत्तर हैं great, और ऐसा लगता है कि noअधिक उत्तर is needed लेकिन मैं बस &&ऑपरेटर के बारे में कुछ इंगित करने के लिए अभ्यस्त हूंdependent condition

ऑपरेटर && का उपयोग करने वाले भावों में, एक dependent conditionशर्त- हम इसे कहेंगे- निर्भर स्थिति के मूल्यांकन के लिए सार्थक होने के लिए हमें एक और शर्त की आवश्यकता होगी।

इस स्थिति में, त्रुटियों को रोकने के लिए निर्भर स्थिति को && ऑपरेटर के बाद रखा जाना चाहिए।

अभिव्यक्ति पर विचार करें (i != 0) && (10 / i == 2)। निर्भर हालत (10 / i == 2)चाहिए ऑपरेटर शून्य से भाग की संभावना को रोकने के लिए।appear after&&

एक और उदाहरण (myObject != null) && (myObject.getValue() == somevaluse)

और एक और बात: &&और ||कहा जाता है शॉर्ट सर्किट मूल्यांकन क्योंकि दूसरा तर्क निष्पादित या मूल्यांकन किया जाता है तर्क करता है करने के लिए कीonly iffirstnot sufficedeterminevalueexpression

संदर्भ: जावा ™ प्रोग्राम (प्रारंभिक वस्तुएँ), दसवां संस्करण