इस बूलियन "(संख्या और 1) == 0" का क्या मतलब है?

Question 1

CodeReview पर मैंने एक काम करने वाला कोड पोस्ट किया और इसे बेहतर बनाने के लिए सुझाव मांगे। मेरे पास एक बूलीयन पद्धति का उपयोग यह जांचने के लिए था कि क्या एक ArrayList में सूचकांकों की संख्या समान थी (जो आवश्यक थी)। यह वह कोड था जो सुझाया गया था:

private static boolean isEven(int number)
{
    return (number & 1) == 0;
}

जैसा कि मैंने पहले से ही उस विशेष उपयोगकर्ता को बहुत मदद के लिए पाला है, मैंने तय किया है कि यह समय है जब मैंने एसओ समुदाय को परेशान कर दिया है! मैं वास्तव में नहीं समझता कि यह कैसे काम करता है। विधि को कहा जाता है और एक पैरामीटर के रूप में ArrayList का आकार लेता है (यानी ArrayList में दस तत्व हैं, संख्या = 10)।

मैं एक एकल जानता हूं & दोनों संख्या और 1 की तुलना में रन बनाता है, लेकिन मैं उसके बाद हार गया।

जिस तरह से मैंने इसे पढ़ा है, वह कह रहा है कि अगर यह सच है number == 0और1 == 0 । मुझे पता है कि पहला सच नहीं है और दूसरा स्पष्ट रूप से समझ में नहीं आता है। क्या कोई मेरी मदद कर सकता है?

संपादित करें: मुझे शायद जोड़ना चाहिए कि अगर कोई सोच रहा हो तो कोड काम करता है।

Question 2

ध्यान रखें कि "और" एक बिटवाइज़ ऑपरेशन है। आप शायद इसके बारे में जानते हैं, लेकिन जिस तरह से आपने सवाल उठाया है, उसके आधार पर यह मेरे लिए पूरी तरह से स्पष्ट नहीं है।

यह कहा जा रहा है, सैद्धांतिक विचार यह है कि आपके पास कुछ अंतर हैं, जिन्हें 1s और 0s की कुछ श्रृंखला द्वारा बिट्स में व्यक्त किया जा सकता है। उदाहरण के लिए:

...10110110

बाइनरी में, क्योंकि यह बेस 2 है, जब भी संख्या का बिटकॉइन संस्करण 0 में समाप्त होता है, तब भी होता है, और जब यह 1 में समाप्त होता है तो यह विषम होता है।

इसलिए, उपरोक्त के लिए एक बिटवाइज़ और 1 के साथ करना निम्न है:

...10110110 & ...00000001

बेशक, यह 0 है, इसलिए आप कह सकते हैं कि मूल इनपुट भी था।

वैकल्पिक रूप से, एक विषम संख्या पर विचार करें। उदाहरण के लिए, हमारे पास जो कुछ था, उसमें 1 जोड़ें। फिर

...10110111 & ...00000001

1 के बराबर है, और इसलिए शून्य के बराबर नहीं है। वोइला।

Question 3

आप बाइनरी प्रतिनिधित्व में अंतिम बिट द्वारा या तो सम या विषम संख्या निर्धारित कर सकते हैं :

1 -> 00000000000000000000000000000001 (odd)
2 -> 00000000000000000000000000000010 (even)
3 -> 00000000000000000000000000000011 (odd)
4 -> 00000000000000000000000000000100 (even)
5 -> 00000000000000000000000000000101 (odd)
6 -> 00000000000000000000000000000110 (even)
7 -> 00000000000000000000000000000111 (odd)
8 -> 00000000000000000000000000001000 (even)

& दो पूर्णांकों के बीच बिटवाइस और ऑपरेटर है:

0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

तो, अगर (number & 1) == 0है true, तो इसका मतलब numberयह भी है।

मान लेते हैं कि number == 6, तब:

6 -> 00000000000000000000000000000110 (even)

     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

1 -> 00000000000000000000000000000001

-------------------------------------

0 -> 00000000000000000000000000000000

और जब number == 7:

7 -> 00000000000000000000000000000111 (odd)

     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

1 -> 00000000000000000000000000000001

-------------------------------------

1 -> 00000000000000000000000000000001

Question 4

&बिटवाइज एंड ऑपरेटर है। &&तार्किक और ऑपरेटर है

बाइनरी में, यदि अंक बिट सेट है (यानी एक), संख्या विषम है।

बाइनरी में, यदि अंक बिट शून्य है, तो संख्या भी है।

(number & 1) एक है बिटवाइज़ और अंक बिट की कसौटी पर।

ऐसा करने का एक और तरीका (और संभवतः कम कुशल लेकिन अधिक समझने योग्य) मापांक ऑपरेटर का उपयोग कर रहा है %:

private static boolean isEven(int number)
{
    if (number < 0)
       throw new ArgumentOutOfRangeException();

    return (number % 2) == 0;
}

Question 5

इस अभिव्यक्ति का अर्थ है "पूर्णांक एक सम संख्या का प्रतिनिधित्व करता है"।

यहाँ कारण है कि क्यों: दशमलव 1का द्विआधारी प्रतिनिधित्व है 00000000001। सभी विषम संख्याएं 1बाइनरी में समाप्त होती हैं (यह सत्यापित करना आसान है: मान लें कि संख्या का बाइनरी प्रतिनिधित्व समाप्त नहीं होता है 1, तो यह दो की गैर-शून्य शक्तियों से बना है, जो हमेशा एक सम संख्या है)। जब आप ANDएक विषम संख्या के साथ एक द्विआधारी करते हैं , तो परिणाम होता है 1; जब आप ANDएक सम संख्या के साथ एक बाइनरी करते हैं , तो परिणाम होता है0 ।

यह उस समय विषम / यहाँ तक कि निर्णय लेने का पसंदीदा तरीका हुआ करता था, जब ऑप्टिमाइज़र नॉनटेक्स्टेंट से खराब थे, और %ऑपरेटरों को एक &ऑपरेटर द्वारा लिए गए चक्रों की संख्या के बीस गुना की आवश्यकता होती थी । इन दिनों, यदि आप करते हैं number % 2 == 0, तो कंपाइलर कोड उत्पन्न करने की संभावना (number & 1) == 0रखता है जो जल्दी से जल्दी निष्पादित होता है।

Question 6

एकल का &अर्थ है बिट-वार andऑपरेटर की तुलना नहीं

तो यह कोड यह जांचता है कि क्या पहला bit(सबसे महत्वपूर्ण / सबसे सही) सेट है या नहीं, जो इंगित करता है कि संख्या है oddया नहीं; क्योंकि सभी विषम संख्याएँ 1कम से कम महत्वपूर्ण बिट के साथ समाप्त होंगीxxxxxxx1

Question 7

&एक बिटवाइज़ ANDऑपरेशन है।

संख्या = 8 के लिए:

नतीजा यह है कि है (8 & 1) == 0। यह सभी सम संख्याओं के मामले में है, क्योंकि वे 2 के गुणक हैं और दायें से पहला बाइनरी अंक हमेशा 0. होता है। 1 में अग्रणी 0 के साथ 1 का बाइनरी मान होता है, इसलिए जब हम ANDइसे एक समान संख्या के साथ छोड़ देते हैं। 0 के साथ।

Question 8

&जावा में ऑपरेटर बिटवाइज़-और ऑपरेटर है। असल में, (number & 1)प्रदर्शन करती एक बिटवाइज़-और के बीच numberऔर1 । परिणाम या तो 0 या 1 है, यह इस बात पर निर्भर करता है कि यह विषम है या विषम। फिर परिणाम की तुलना 0 के साथ की जाती है ताकि यह निर्धारित किया जा सके कि यह भी है।

यहां बिटवाइज़ ऑपरेशंस का वर्णन करने वाला एक पेज है ।

Question 9

यह एक बाइनरी प्रदर्शन कर रहा है और 1 के खिलाफ है, जो 0 लौटाता है यदि कम से कम महत्वपूर्ण बिट सेट नहीं है

अपने उदाहरण के लिए

00001010 (10)

00000001 (1)

===========

00000000 (0)

Question 10

यह लॉजिकल डिजाइन कॉन्सेप्ट बिटवाइंड एंड (AND) ऑपरेटर है।

वापसी (2 & 1); का अर्थ है- मूल्य को बिटवाइज़ नंबरों में परिवर्तित करना और (और) फ़ीचर को वापस करना और वैल्यू लौटा देना।

इस लिंक को देखें http://www.roseindia.net/java/master-java/java-bitwise-and.shtml