हम आमतौर पर क्यों इस्तेमाल करते हैं || ओवर

219

मैं बस सोच रहा हूं कि हम आम तौर पर तार्किक या ||दो बूलियन के बीच बिटवाइज़ या नहीं का उपयोग |करते हैं, हालांकि वे दोनों अच्छी तरह से काम कर रहे हैं।

मेरा मतलब है, निम्नलिखित को देखें:

if(true  | true)  // pass
if(true  | false) // pass
if(false | true)  // pass
if(false | false) // no pass

if(true  || true)  // pass
if(true  || false) // pass
if(false || true)  // pass
if(false || false) // no pass

क्या हम |इसके बजाय उपयोग कर सकते हैं ||? के साथ &और बात &&।

java bitwise-operators

— Eng.Fouad
स्रोत

16

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

— जॉन मेघेर

1

अंतर पर विवरण जेएलएस में हैं। Java.sun.com/docs/books/jls/third_edition/html/…

— जॉन

64

वे एक जैसे नहीं हैं। कृपया शॉर्ट-सर्किट मूल्यांकन बनाम उत्सुक मूल्यांकन के बारे में विशेष रूप से उन पर ट्यूटोरियल देखें । ||और &&शॉर्ट सर्किट, जबकि |और &उत्सुक हैं।

— होल्सक्राफ्ट पूरा ईल

4

जिज्ञासा से बाहर, वास्तव में आप किस स्थिति में गैर-शॉर्ट सर्कुलेटेड संस्करणों का उपयोग करना चाहेंगे? मैं लगभग हमेशा देखता हूं &&और ||, लेकिन कभी नहीं & |। यदि आप कुछ ऐसा कर रहे हैं जो साइड इफेक्ट्स पर निर्भर करता है, तो मैं यह नहीं देखता कि आप ऐसा कुछ क्यों इस्तेमाल करेंगे (a & b | c)क्योंकि कोई व्यक्ति आसानी से सोच सकता है "मैं इसे छोटे सर्कुलेटेड संस्करणों का उपयोग करके अनुकूलित कर सकता हूं।"

— माइक बेली

2

और, ज़ाहिर है, उनकी अलग-अलग मिसाल है।

— हॉट लिक्स

349

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

अगर आप शॉर्ट सर्किट के लिए मूल्यांकन या नहीं चाहते की बात है - सबसे बार जब आप करना चाहते हैं।

शॉर्ट-सर्किटिंग के लाभों को चित्रित करने का एक अच्छा तरीका निम्नलिखित उदाहरण पर विचार करना होगा।

Boolean b = true;
if(b || foo.timeConsumingCall())
{
   //we entered without calling timeConsumingCall()
}

एक अन्य लाभ, जैसा कि जेरेमी और पीटर ने उल्लेख किया है, शॉर्ट-सर्किटिंग के लिए अशक्त संदर्भ जांच है:

if(string != null && string.isEmpty())
{
    //we check for string being null before calling isEmpty()
}

और जानकारी

— शॉन
स्रोत

115

विहित उदाहरणfoo != null && foo.hasBar()

— जेरेमी

1

यदि आप लगभग अशक्त संदर्भ अपवाद का उपयोग करके जोड़ते हैं | @ जेरेमी की टिप्पणी से तो यह बहुत अच्छा जवाब है।

— पीटर केली

यह भी याद रखें कि && और || मशीन कोड स्तर पर एक शाखा निर्देश का अर्थ है (याद रखें कि शाखाएं शाखा गलतफहमी पैदा कर सकती हैं), इसलिए यदि आप प्रदर्शन के बारे में सुपर-पांडित्य हैं, तो केवल उनका उपयोग करें जब वे वास्तव में आवश्यक हों ( foo != null && foo.hasBar()या तेजी से b || foo.timeConsumingCall()) ( )। 99% डेवलपर्स को इस स्तर के सूक्ष्म अनुकूलन के बारे में चिंता करने की आवश्यकता नहीं है।

— जोनाथन डिकिंसन

3

जब आप उपयोग करना चाहते हैं तो मैं उल्लेखित आश्चर्यचकित हूं। सबसे आम परिदृश्य जो मैं इसका उपयोग करता हूं वह है जब एक चर को चेक में संशोधित किया जाता है जैसे (j> 3 | ++ i> 3) या (++ i> 3 | modifiesGlobalAmongOtherThings () = true)। हालांकि बहुत आम नहीं है।

— एंडसो यूकोड

8

एक और विहित उदाहरण है string == null || string.isEmpty();)

— पीटर लॉरी

83

| बूलियन अभिव्यक्तियों में शॉर्ट-सर्किट मूल्यांकन नहीं करता है । ||पहले ऑपरेंड सच है, लेकिन मूल्यांकन करना बंद कर देंगे, लेकिन |नहीं होगा।

इसके अलावा, |बाइट / शॉर्ट / इंट / लॉन्ग वैल्यू पर बिटवाइज़-या ऑपरेशन करने के लिए इस्तेमाल किया जा सकता है। ||नही सकता।

— माइकल मायर्स
स्रोत

पूर्ण उत्तर दें और मैं इसे स्वीकार करूंगा। अब तक आप सबसे पहले इसके इस पहलू को उठा रहे हैं।

— जॉन मेघेर सेप

का बिटवाइस पहलू गुम |

— जॉन मेघेर

63

तो उदाहरण के साथ अन्य उत्तरों पर निर्माण करने के लिए, निम्न-रक्षात्मक जांच में शॉर्ट-सर्कुलेटिंग महत्वपूर्ण है:

if (foo == null || foo.isClosed()) {
    return;
}

if (bar != null && bar.isBlue()) {
    foo.doSomething();
}

उपयोग करने |और &बदले में NullPointerExceptionयहाँ फेंका जा सकता है।

— पॉल बेलोरा
स्रोत

यदि आपने NullObject पैटर्न लागू किया है तो यह (या उत्तर को नकारना नहीं होगा)। इसके अलावा, मैं कहूँगा कि क्या जाँच है कि फू नीले रंग का है या नहीं। यदि यह नीला है, तो doSomething को कुछ नहीं करना चाहिए।

— निकोडेमस 13

@ निकोडेमस 13 - अच्छे बिंदु, हालांकि नल ऑब्जेक्ट पैटर्न केवल कभी-कभी वांछनीय है, और शरीर को किसी भी कॉल के अलावा कुछ और हो सकता है foo। पीटर लॉरी का "कैनोनिकल उदाहरण" सबसे अच्छा है।

— पॉल बेलोरा

@Khan: हाँ, मैं बल्कि खतरनाक था, और अशक्त वस्तु हमेशा उपयुक्त नहीं है। मैं सिर्फ उप-सचेत रूप से चीजों को फिर से बनाने की आदत में पड़ गया हूं। आपके उत्तर में कुछ भी गलत नहीं है।

— निकोडेमस 13

39

तार्किक ||और &&सही हाथ की जाँच करें यदि आवश्यक हो तो ही। |और &जाँच दोनों पक्षों हर।

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

int i = 12;
if (i == 10 & i < 9) // It will check if i == 10 and if i < 9
...

इसे फिर से लिखें:

int i = 12;
if (i == 10 && i < 9) // It will check if i == 10 and stop checking afterward because i != 10
...

एक और उदाहरण:

int i = 12;
if (i == 12 | i > 10) // It will check if i == 12 and it will check if i > 10
...

इसे फिर से लिखें:

int i = 12;
if (i == 12 || i > 10) // It will check if i == 12, it does, so it stops checking and executes what is in the if statement
...

— dair
स्रोत

18

एक सामान्य गड़बड़ी पर भी गौर करें: गैर आलसी संचालकों में आलसी लोगों की पूर्वता होती है, इसलिए:

boolean a, b, c;
a || b && c; //resolves to a || (b && c)
a | b && c; //resolves to (a | b) && c

इन्हें मिलाते समय सावधान रहें।

— मिस्टर स्मिथ
स्रोत

15

शॉर्ट-सर्किटिंग के अलावा, एक और बात ध्यान में रखना है कि मानों पर एक बिटवाइज़ लॉजिक ऑपरेशन करना जो 0 या 1 के अलावा हो सकता है, सशर्त लॉजिक की तुलना में बहुत अलग अर्थ रखता है। हालांकि यह USUALLY के लिए समान है |और ||, इसके साथ &और &&आपको बहुत अलग परिणाम मिलते हैं (जैसे 2 & 4कि 0 / गलत है जबकि 2 && 41 / सच है)।

यदि आप किसी फ़ंक्शन से प्राप्त कर रहे हैं, तो वास्तव में एक त्रुटि कोड है और आप गैर-0-नेस के लिए परीक्षण कर रहे हैं, यह काफी मायने रख सकता है।

यह जावा में एक समस्या के रूप में नहीं है जहाँ आपको बूलियन के लिए स्पष्ट रूप से टाइपकास्ट करना है या 0 या इस तरह की तुलना करना है, लेकिन समान सिंटैक्स (C / C ++ et al) के साथ अन्य भाषाओं में यह काफी भ्रामक हो सकता है।

इसके अलावा, ध्यान दें कि और | केवल पूर्णांक-प्रकार के मूल्यों पर लागू हो सकता है, और सब कुछ नहीं जो बूलियन टेस्ट के बराबर हो सकता है। फिर, गैर-जावा भाषाओं में, काफी कुछ चीजें हैं जो एक अंतर्निहित != 0तुलना के साथ बूलियन के रूप में इस्तेमाल की जा सकती हैं (बिंदु, फ्लोट, एक के साथ ऑब्जेक्ट operator bool(), आदि) और बिटवाइज़ ऑपरेटर लगभग उन संदर्भों में निरर्थक हैं।

— शराबी
स्रोत

3

मुझे खुशी है कि कम से कम किसी ने बिटवाइज ऑपरेटरों के अस्तित्व के पूरे उद्देश्य का उल्लेख किया।

— ulidtko

9

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

हालांकि, यह एक माइक्रो-ऑप्टिमाइज़ेशन है जो शायद ही कभी सबसे निचले स्तर के कोड को छोड़कर मायने रखता है।

— पीटर लॉरी
स्रोत

1

यह दिलचस्प होगा कि कंपाइलर कुछ मामलों में स्वचालित रूप से ऐसा करता है या नहीं।

— स्टारब्ले

शायद JIT हो सकता है, लेकिन संकलक केवल साधारण अनुकूलन के साथ सौदा करता है।

— पीटर लॉरी

2

हां, मैंने ऐसी परिस्थितियां भी देखी हैं जहां | की शाखा ओवरहेड की तुलना में काफी तेज है, विशेष रूप से सीपीयू पर बिना या सीमित शाखा भविष्यवाणी के। यह दुर्लभ है, लेकिन अनसुना नहीं है। मेरे एक सहकर्मी ने एक ठेकेदार के साथ कुछ कोड में एक उलटा युद्ध किया क्योंकि वह (सही तरीके से) उपयोग कर रहा था और ठेकेदार यह सोचता रहा कि "गलत था।"

— शराबी

4

@Fluffy, कहानी का नैतिक यह है कि यदि आप कुछ मुश्किल करते हैं, तो यह टिप्पणी करने की आवश्यकता है कि आपने ऐसा क्यों किया या आपके प्रयासों को बाद में बर्बाद किया जा सकता है। ;)

— पीटर लॉरी

1

हाँ, आखिरकार उन्होंने एक टिप्पणी जोड़ दी (मेरे सुझाव पर कि ठेकेदार को 'फिक्सिंग' को कैसे रोकना है), और सब ठीक है।

— शराबी

8

|| तार्किक या ऑपरेटर है जबकि | बिटवाइज़ या ऑपरेटर है।

boolean a = true;
boolean b = false;

if (a || b) {
}

int a = 0x0001;
a = a | 0x0002;

— जोर्ज फेरेरा
स्रोत

1

मिसिंग है कि | एक गैर-शॉर्ट-सर्कुलेटिंग बूलियन ऑपरेटर भी है।

— जॉन मेघेर

2

@ जॉन मेघेर: यह अंतर्निहित है, क्योंकि यह बिटवाइज़ है ।

— L --o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e

@ L @o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e did आपने अपनी प्रोफ़ाइल में अपना नाम अलग शैली कैसे बनाया?

— उदयकिरण पुलिपति

8

ए | बी: किसी भी मामले में बी का मूल्यांकन करें

ए || बी: बी का मूल्यांकन केवल अगर गलत का मूल्यांकन करता है

— user18596
स्रोत

7

इस तथ्य के अतिरिक्त | एक बिटवाइज़-ऑपरेटर है: || एक शॉर्ट-सर्किट ऑपरेटर है - जब एक तत्व गलत है, तो यह दूसरों की जांच नहीं करेगा।

 if(something || someotherthing)
 if(something | someotherthing)

अगर कुछ सच है, || कुछ का मूल्यांकन नहीं करेंगे, जबकि | करूँगा। यदि आपके if- स्टेटमेंट्स में वैरिएबल वास्तव में फंक्शन कॉल्स हैं, का उपयोग करते हुए || संभवतः बहुत सारे प्रदर्शन को बचा रहा है।

— माइकल स्टम
स्रोत

आप कभी क्यों इस्तेमाल करेंगे | एक if स्टेटमेंट में || बूलियन है, | नहीं है, | यदि आपका पहले से ही दो बूलियन मूल्यों पर काम कर रहा है तो यह केवल बूलियन होगा।

— फ्लाईसवाट

यह सब पाने का पहला जवाब है।

— जॉन मेघेर

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

— माइकल मायर्स

बुरा करने के लिए यह एक बिल्कुल हास्यास्पद उदाहरण है।

— फ्लाईसवाट

मुझे कोई अंदाजा नहीं है कि कोई क्यों इस्तेमाल करेगा | या सरल बूलियन तुलना के लिए एक if-statement में, लेकिन यह पूरी तरह से कानूनी है, और मैंने वास्तव में इसके उदाहरण देखे हैं जब मैंने प्रोग्रामिंग सीखना शुरू किया था।

— माइकल Stum

3

| is the binary or operator

|| is the logic or operator

— लुकास एस।
स्रोत

2

मिसिंग है कि | एक गैर-शॉर्ट-सर्कुलेटिंग बूलियन ऑपरेटर भी है।

— जॉन मेघेर

3

ऑपरेटरों ||और &&कहा जाता है सशर्त ऑपरेटरों , जबकि |और &कहा जाता है ऑपरेटरों बिटवाइज़ । वे विभिन्न उद्देश्यों की पूर्ति करते हैं।

सशर्त संचालक केवल उन अभिव्यक्तियों के साथ काम booleanकरते हैं जो बाएं और दाएं-बाएं दोनों पक्षों पर सांख्यिकीय रूप से मूल्यांकन करते हैं ।

बिटवाइज़ ऑपरेटर किसी भी संख्यात्मक ऑपरेंड के साथ काम करता है।

यदि आप तार्किक तुलना करना चाहते हैं, तो आपको सशर्त ऑपरेटरों का उपयोग करना चाहिए , क्योंकि आप अपने कोड में कुछ प्रकार की सुरक्षा जोड़ लेंगे।

— ब्रूनो रीस
स्रोत

उम, |और &सशर्त ऑपरेटर भी हैं। कृपया मेरी टिप्पणी का लिंक मूल पोस्ट में देखें।

— ईल

@ हैवरक्राफ्ट ईल्स से भरा: वह चार्ट थोड़ा भ्रामक है; यह उन्हें सशर्त ऑपरेटरों के रूप में संदर्भित कर रहा है केवल बूलियन मूल्यों के संदर्भ में, जहां वे गणितीय रूप से उत्सुक तार्किक ऑपरेटरों के बराबर हैं। जब आप उन चीजों से निपटना शुरू कर देते हैं जिनमें 0 या 1 के अलावा अन्य मूल्य हैं, या फ्लोटिंग पॉइंट वैल्यू या पॉइंटर्स या जो कुछ भी है, तुलना टूट जाती है।

— शराबी

@fluffy: चार्ट के बारे में कुछ भी भ्रामक नहीं है क्योंकि चर्चा केवल बूलियन ऑपरेटरों के बारे में थी। बिट-वार ऑपरेटरों के रूप में इसका उपयोग किया जा सकता है |और यह &पूरी तरह से एक अलग मुद्दा है।

— ईल

1

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

— शराबी

2

एक साइड नोट: जावा में = = है, लेकिन ए = नहीं है

जब आप का उपयोग करना चाहिए का एक उदाहरण || जब पहली अभिव्यक्ति यह देखने के लिए एक परीक्षण है कि क्या दूसरी अभिव्यक्ति उड़ जाएगी। उदा। एकल का उपयोग करना | hte निम्नलिखित मामले में एक NPE में परिणाम हो सकता है।

public static boolean isNotSet(String text) {
   return text == null || text.length() == 0;
}

— पीटर लॉरी
स्रोत

2

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

&और |या तो इंटेगर बिटवाइज ऑपरेटर्स, या बूलियन लॉजिकल ऑपरेटर्स हो सकते हैं। बिटवाइज़ और लॉजिकल ऑपरेटर्स के लिए वाक्य रचना ( 215.22 ) है:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

वाक्य रचना के लिए EqualityExpressionमें परिभाषित किया गया है §15.21 , जो आवश्यकता RelationalExpressionके रूप में परिभाषित §15.20 , जो बारी में की आवश्यकता है ShiftExpressionऔर ReferenceTypeमें परिभाषित §15.19 और §4.3 , क्रमशः। ShiftExpressionमें AdditiveExpressionपरिभाषित किया गया हैdefined15.18 , जो कि मूल अंकगणित, एकरी संचालकों आदि को परिभाषित करते हुए ड्रिल करने के लिए जारी रहती है, जो ReferenceTypeएक प्रकार का प्रतिनिधित्व करने के लिए सभी विभिन्न तरीकों से नीचे जाती है। (जबकि ReferenceTypeआदिम प्रकार शामिल नहीं है, आदिम प्रकार की परिभाषा अंततः, के लिए आवश्यक है के रूप में वे एक सरणी है, जिसके लिए आयाम प्रकार हो सकता है है एक ReferenceType।)

बिटवाइज़ और लॉजिकल ऑपरेटर्स के निम्नलिखित गुण हैं:

इन ऑपरेटरों की अलग-अलग मिसालें हैं, जिनमें &सबसे ज्यादा मिसाल और |सबसे कम मिसाल है।

इनमें से प्रत्येक ऑपरेटर वाक्यात्मक रूप से बाएं-सहयोगी (प्रत्येक समूह बाएं से दाएं) है।

यदि प्रत्येक ऑपरेटर के कोई साइड इफेक्ट नहीं हैं, तो प्रत्येक ऑपरेटर सराहनीय है।

प्रत्येक ऑपरेटर सहयोगी है।

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

चाहे ऑपरेटर एक बिटवाइज़ ऑपरेटर या एक तार्किक ऑपरेटर के रूप में कार्य करता है के बीच भेद ऑपरेंड ( "एक आदिम अभिन्न प्रकार के लिए परिवर्तनीय" कर रहे हैं पर निर्भर करता §4.2 ) या वे प्रकार के होते हैं, तो booleanया Boolean( §5.1.8 ) के हैं।

यदि ऑपरेंड अभिन्न प्रकार के होते हैं, तो दोनों ऑपरेंड पर बाइनरी न्यूमेरिक प्रमोशन ( ands5.6.2 ) किया जाता है, इन दोनों को ऑपरेशन के लिए longया तो छोड़ दिया जाता है int। ऑपरेशन का प्रकार (पदोन्नत) ऑपरेंड्स का प्रकार होगा। उस बिंदु पर, &बिटवाइज़ और, ^बिटवाइज़ एक्सक्लूसिव OR |होगा , और बिटवाइज़ इंक्लूसिव OR होगा। ( 215.22.1 )

यदि ऑपरेंड हैं booleanया Boolean, यदि आवश्यक हो ( .15.1.8 ), तो ऑपरेंड अनबॉक्सिंग रूपांतरण के अधीन होगा और ऑपरेशन का प्रकार होगा boolean। &परिणाम देगा में trueदोनों ऑपरेंड कर रहे हैं true, ^में परिणाम होगा trueअगर दोनों ऑपरेंड अलग हैं, और |में परिणाम होगा trueयदि या तो संकार्य है true। ( 215.22.2) )

इसके विपरीत, && " कंडिशनल -एंड ऑपरेटर" ( 315.23 ) है और " कंडिशनल|| -ऑर ऑपरेटर" (" 15.24 ) है। उनके सिंटैक्स को इस प्रकार परिभाषित किया गया है:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&यह पसंद है &, सिवाय इसके कि यह केवल सही ऑपरेंड का मूल्यांकन करता है यदि बाएं ऑपरेंड है true। ||यह पसंद है |, सिवाय इसके कि यह केवल सही ऑपरेंड का मूल्यांकन करता है यदि बाएं ऑपरेंड हैfalse ।

सशर्त और निम्नलिखित गुण हैं:

सशर्त-ऑपरेटर और ऑपरेटर वाक्यात्मक रूप से बाएं-साहचर्य है (यह समूह बाएं से दाएं)।

सशर्त-और ऑपरेटर साइड इफेक्ट और परिणाम मूल्य दोनों के संबंध में पूरी तरह से सहयोगी है। यही कारण है कि, किसी भी भाव के लिए किया जाता है a, bऔर c, अभिव्यक्ति के मूल्यांकन ((a) && (b)) && (c)एक ही परिणाम, उत्पादन उसी क्रम में होने वाली एक ही साइड इफेक्ट के साथ अभिव्यक्ति के मूल्यांकन के रूप में(a) && ((b) && (c)) ।

सशर्त-और ऑपरेटर के प्रत्येक प्रकार के प्रकार booleanया होने चाहिएBoolean , या एक संकलन-समय त्रुटि होती है।

एक सशर्त और अभिव्यक्ति का प्रकार हमेशा होता है boolean ।

रन समय में, बाएं हाथ की ऑपरेंड अभिव्यक्ति का मूल्यांकन पहले किया जाता है; यदि परिणाम में टाइप है Boolean, तो यह अनबॉक्सिंग रूपांतरण ( .85.1.8 ) के अधीन है ।

यदि परिणामी मूल्य है false, तो सशर्त-और अभिव्यक्ति का मूल्य है falseऔर दाहिने हाथ की ऑपरेंड अभिव्यक्ति का मूल्यांकन नहीं किया गया है।

यदि बाएं हाथ के संचालन का मूल्य है true, तो दाहिने हाथ की अभिव्यक्ति का मूल्यांकन किया जाता है; यदि परिणाम में टाइप है Boolean, तो यह अनबॉक्सिंग रूपांतरण ( .85.1.8 ) के अधीन है । परिणामी मूल्य सशर्त-और अभिव्यक्ति का मूल्य बन जाता है।

इस प्रकार, &&के रूप में एक ही परिणाम की गणना &पर booleanऑपरेंड। यह केवल इस बात में भिन्न है कि दाएं हाथ की ऑपरेंड अभिव्यक्ति का मूल्यांकन हमेशा के बजाय सशर्त रूप से किया जाता है।

सशर्त-या में निम्नलिखित गुण हैं:

सशर्त-या ऑपरेटर वाक्यात्मक रूप से बाएं-साहचर्य है (यह समूह बाएं से दाएं)।

सशर्त या ऑपरेटर पूरी तरह से साइड इफेक्ट और परिणाम मूल्य दोनों के संबंध में सहयोगी है। यह है कि, किसी भी भाव के लिए a, bहै, और c, अभिव्यक्ति के मूल्यांकन ((a) || (b)) || (c)एक ही परिणाम, एक ही साइड इफेक्ट, उसी क्रम में होने वाली अभिव्यक्ति के मूल्यांकन के रूप में के साथ पैदा करता है (a) || ((b) || (c))।

सशर्त-या ऑपरेटर का प्रत्येक संचालक प्रकार का होना चाहिए booleanया Boolean, या संकलन-समय त्रुटि उत्पन्न हो सकती है।

सशर्त-या अभिव्यक्ति का प्रकार हमेशा होता है boolean ।

रन समय में, बाएं हाथ की ऑपरेंड अभिव्यक्ति का मूल्यांकन पहले किया जाता है; यदि परिणाम में टाइप है Boolean, तो यह अनबॉक्सिंग रूपांतरण ( .85.1.8 ) के अधीन है ।

यदि परिणामी मूल्य है true, तो सशर्त-या अभिव्यक्ति का मूल्य है trueऔर दाहिने हाथ की ऑपरेंड अभिव्यक्ति का मूल्यांकन नहीं किया गया है।

यदि बाएं हाथ के संचालन का मूल्य है false, तो दाहिने हाथ की अभिव्यक्ति का मूल्यांकन किया जाता है; यदि परिणाम में टाइप है Boolean, तो यह अनबॉक्सिंग रूपांतरण ( .85.1.8 ) के अधीन है । परिणामी मूल्य सशर्त-या अभिव्यक्ति का मूल्य बन जाता है।

इस प्रकार, पर या ऑपरेंड ||के समान परिणाम की गणना करता है। यह केवल इस बात में भिन्न है कि दाएं हाथ की ऑपरेंड अभिव्यक्ति का मूल्यांकन हमेशा के बजाय सशर्त रूप से किया जाता है।|booleanBoolean

संक्षेप में, @JohnMeagher ने बार-बार टिप्पणियों में बताया है, &और |वास्तव में, ऑपरेंड के विशिष्ट मामले में गैर-शॉर्ट-सर्कुलेटिंग बूलियन ऑपरेटर हैं booleanया Boolean। अच्छी प्रथाओं के साथ (यानी: कोई माध्यमिक प्रभाव नहीं), यह एक मामूली अंतर है। जब ऑपरेंड्स booleanएस या Booleanएस नहीं होते हैं , हालांकि, ऑपरेटर बहुत अलग तरीके से व्यवहार करते हैं : बिटवाइज़ और लॉजिकल ऑपरेशंस बस जावा प्रोग्रामिंग के उच्च स्तर पर अच्छी तरह से तुलना नहीं करते हैं।

— ब्रायन एस
स्रोत

2

1)। (अभिव्यक्ति 1 | अभिव्यक्ति 2), संचालक अभिव्यक्ति 2 का मूल्यांकन करेगा चाहे वह अभिव्यक्ति 1 का परिणाम सही हो या गलत।

उदाहरण:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b | test());
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

2)। (अभिव्यक्ति 1 || अभिव्यक्ति 2), || ऑपरेटर अभिव्यक्ति 2 सत्य होने पर अभिव्यक्ति 2 का मूल्यांकन नहीं करेगा।

उदाहरण:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b || test())
        {
            System.out.println("short circuit!");
        }
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

— Veeresh
स्रोत

1

|| दो मानों के आधार पर एक बूलियन मान लौटाता है (यही कारण है कि इसे लॉजिकल या के रूप में जाना जाता है)

अर्थात:

if (A || B)

यदि A या B सत्य है, या असत्य है, यदि वे दोनों असत्य हैं, तो सत्य लौटेगा।

| एक ऑपरेटर है जो दो मानों पर एक बिटवाइज़ ऑपरेशन करता है। बिटवाइज़ ऑपरेशंस को बेहतर ढंग से समझने के लिए, आप यहाँ पढ़ सकते हैं:

http://en.wikipedia.org/wiki/Bitwise_operation

— FlySwat
स्रोत

1

एक मुख्य अंतर यह है कि || और && "लघु-परिशोधन" प्रदर्शित करता है, इसलिए यदि आवश्यक हो तो आरएचएस का केवल मूल्यांकन किया जाएगा।

उदाहरण के लिए

if (a || b) {
    path1...
} else {
    path2..
}

ऊपर यदि कोई सत्य है तो b का परीक्षण नहीं किया जाएगा और path1 निष्पादित हो गया है। अगर | उपयोग किया गया था, तब दोनों पक्षों का मूल्यांकन किया जाएगा भले ही 'a' सत्य हो।

यहाँ और यहाँ देखें , एक छोटे से अधिक जानकारी के लिए।

उम्मीद है की यह मदद करेगा।

— एलेक्स एच
स्रोत

1

गैर-लघु-परिशोधन उपयोगी हो सकता है। कभी-कभी आप यह सुनिश्चित करना चाहते हैं कि दो अभिव्यक्ति का मूल्यांकन करें। उदाहरण के लिए, मान लें कि आपके पास एक विधि है जो किसी ऑब्जेक्ट को दो अलग-अलग सूचियों से निकालती है। आप ऐसा कुछ करना चाहते हैं:

class foo {

    ArrayList<Bar> list1 = new ArrayList<Bar>();
    ArrayList<Bar> list2 = new ArrayList<Bar>();

    //Returns true if bar is removed from both lists, otherwise false.
    boolean removeBar(Bar bar) {
        return (list1.remove(bar) & list2.remove(bar));
    }
}

यदि आपका तरीका इसके बजाय सशर्त ऑपरेंड का उपयोग करता है, तो यह पहली सूची के गलत होने पर दूसरी सूची से ऑब्जेक्ट को हटाने में विफल होगा।

//Fails to execute the second remove if the first returns false.
boolean removeBar(Bar bar) {
    return (list1.remove(bar) && list2.remove(bar));
}

यह आश्चर्यजनक रूप से उपयोगी नहीं है, और (अधिकांश प्रोग्रामिंग कार्यों के साथ) आप इसे अन्य साधनों के साथ प्राप्त कर सकते हैं। लेकिन यह बिटवाइज़ ऑपरेंड्स के लिए उपयोग का मामला है।

— ktbiz
स्रोत

1

उनके बीच मूल अंतर यह है कि | पहले मानों को बाइनरी में परिवर्तित करता है और फिर बिट वार या ऑपरेशन करता है। इस बीच, || डेटा को बाइनरी में परिवर्तित नहीं करता है और यह मूल स्थिति पर या अभिव्यक्ति करता है।

int two = -2; int four = -4;
result = two | four; // bitwise OR example

System.out.println(Integer.toBinaryString(two));
System.out.println(Integer.toBinaryString(four));
System.out.println(Integer.toBinaryString(result));

Output:
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111110

और अधिक पढ़ें: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

— अविनाश नाथ
स्रोत

जब ऑपरेंड बूलियन, और बेवकूफ स्वरूपण कर रहे हों तो असत्य।

— लोर्न

2

यह समझने में मेरे लिए मददगार था कि Long.valueOf (100 | 200) = 236 क्यों यहाँ है: 0 1 1 0 0 1 1 0 0 | 1 1 0 0 1 0 0 0 = 1 1 1 0 1 1 0 0 = 128 64 32 0 8 4 0 0 = 236

— donils

1

जब मेरे पास यह प्रश्न था तो मैंने इस बारे में एक विचार प्राप्त करने के लिए परीक्षण कोड बनाया।

public class HelloWorld{

   public static boolean bool(){
      System.out.println("Bool");
      return true;
   }

   public static void main(String []args){

     boolean a = true;
     boolean b = false;

     if(a||bool())
     {
        System.out.println("If condition executed"); 
     }
     else{
         System.out.println("Else condition executed");
     }

 }
}

इस स्थिति में, हम केवल बाईं ओर के मूल्य को बदलते हैं यदि स्थिति एक या बी जोड़ रही है।

|| परिदृश्य, जब बाईं ओर सच है [अगर (a (बूल ())]

उत्पादन "If condition executed"

|| परिदृश्य, जब बाईं ओर झूठी [अगर (b || बूल ())]

आउटपुट

Bool
If condition executed

Conclusion of || उपयोग करते समय ||, दाईं ओर केवल तभी जांचें जब बाईं ओर झूठी है।

| परिदृश्य, जब बाईं ओर सच है [अगर (| बूल ())]

आउटपुट

Bool
If condition executed

| परिदृश्य, जब बाईं ओर झूठी [अगर (b। बूल ())]

आउटपुट

Bool
If condition executed

Conclusion of | उपयोग करते समय |, बाईं और दाईं ओर दोनों जांचें।

— JustCode
स्रोत

0

| = बिटवाइज़ या, || = तर्क या

— MagicKat
स्रोत

2

मिसिंग है कि | एक गैर-शॉर्ट-सर्कुलेटिंग बूलियन ऑपरेटर भी है।

— जॉन मेघेर

0

आमतौर पर मैं तब उपयोग करता हूं जब पूर्व वेतन वृद्धि और पोस्ट वेतन वृद्धि ऑपरेटर होता है। निम्नलिखित कोड देखें:

package ocjpPractice;
/**
 * @author tithik
 *
 */
public class Ex1 {

    public static void main(String[] args) {
    int i=10;
    int j=9;
    int x=10;
    int y=9;
    if(i==10 | ++i>j){
        System.out.println("it will print in first if");  
        System.out.println("i is: "+i);
    }

    if(x==10 ||++x>y){
        System.out.println("it will print in second if");   
        System.out.println("x is: "+x);
    }
    }
}

उत्पादन:

अगर
मैं है तो यह पहले प्रिंट करेगा : 11

यह दूसरे में प्रिंट होगा यदि
x है: 10

दोनों ifब्लॉक समान हैं लेकिन परिणाम अलग है। जब है |, दोनों स्थितियों का मूल्यांकन किया जाएगा। लेकिन अगर यह है ||, तो यह दूसरी स्थिति का मूल्यांकन नहीं करेगा क्योंकि पहली शर्त पहले से ही सच है।

— तिथि
स्रोत

1

मुझे यह बहुत भ्रामक लगता है

— निमचिम्स्की

0

कई उपयोग के मामले हैं जो सुझाव देते हैं कि आपको इसके ||बजाय क्यों जाना चाहिए |। कुछ उपयोग मामलों को| सभी स्थितियों की जांच के लिए ऑपरेटर का उपयोग करना पड़ता है ।

उदाहरण के लिए, यदि आप प्रपत्र सत्यापन की जांच करना चाहते हैं और आप उपयोगकर्ता को केवल पहले अमान्य क्षेत्र के बजाय त्रुटि पाठ वाले सभी अमान्य फ़ील्ड दिखाना चाहते हैं ।

|| ऑपरेटर होगा,

   if(checkIfEmpty(nameField) || checkIfEmpty(phoneField) || checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

   private boolean checkIfEmpty(Widget field) {
      if(field.isEmpty()) {
        field.setErrorMessage("Should not be empty!");
        return true;
      }
      return false;
   }

इसलिए स्निपेट के साथ, यदि उपयोगकर्ता सभी खाली फ़ील्ड के साथ फ़ॉर्म सबमिट करता है, तो केवल nameFieldत्रुटि संदेश के साथ दिखाया जाएगा। लेकिन, अगर आप इसे बदलते हैं,

   if(checkIfEmpty(nameField) | checkIfEmpty(phoneField) | checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

यह trueशर्तों के बावजूद प्रत्येक क्षेत्र पर उचित त्रुटि संदेश दिखाएगा ।

— भारथ मग
स्रोत

0

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

मैंने हाल ही में एक टिप्पणी को संबोधित करते हुए एक अनुरोध में कोड को संशोधित किया है

if(function1() | function2()){
  ...
}

को बदलना पड़ा

boolean isChanged = function1();
isChanged |= function2();
if (isChanged){
  ...
}

वास्तविक स्वीकृत संस्करण क्या है?

जावा दस्तावेज़ीकरण एक तार्किक गैर-शॉर्टसर्किटिंग या ऑपरेटर के रूप में उल्लेख नहीं कर रहा है| ।

एक वोट में दिलचस्पी नहीं है, लेकिन मानक का पता लगाने में अधिक है ?! दोनों कोड संस्करण उम्मीद के मुताबिक संकलन और काम कर रहे हैं।

— दान एम
स्रोत

-1

|| एक तार्किक या है | थोड़ा समझदार है या।

— स्टीव मोयर
स्रोत

-1

जावा ऑपरेटर

| बिटवाइज़ है या, || तार्किक है या।

— diciu
स्रोत

-1

पर एक नज़र डालें:

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/operators.html

| बिटवार समावेशी है या

|| तार्किक है या

— जेरेमी
स्रोत

1

मिसिंग है कि | एक गैर-शॉर्ट-सर्कुलेटिंग बूलियन ऑपरेटर भी है।

— जॉन मेघेर

-2

| एक बिटवाइज़ ऑपरेटर है। || एक तार्किक ऑपरेटर है।

एक दो बिट और उन्हें ले जाएगा।

एक सत्य का निर्धारण करेगा (यह या वह) यदि यह सत्य है या वह सत्य है, तो उत्तर सत्य है।

ओह, और खतरे के लोग तेजी से इन सवालों का जवाब देते हैं।

— scubabbl
स्रोत

हम आमतौर पर क्यों इस्तेमाल करते हैं || ओवर | अंतर क्या है?