जावा बिटवाइज़ ऑपरेटर्स

आज के पाठ में, हम जावा बिटवाइज़ ऑपरेटरों से परिचित होंगे और उनके साथ काम करने के उदाहरणों पर विचार करेंगे। आप शायद "बिट" शब्द से परिचित हैं। यदि नहीं, तो आइए याद करें कि इसका क्या अर्थ है :) एक बिट कंप्यूटर में सूचना की सबसे छोटी इकाई है। इसका नाम बाइनरी डिजिट से आया है । एक बिट को दो संख्याओं में से एक द्वारा व्यक्त किया जा सकता है: 1 या 0. एक और शून्य पर आधारित एक विशेष बाइनरी संख्या प्रणाली है। हम यहां गणितीय जंगल में नहीं जाएंगे। हम केवल यह ध्यान देंगे कि जावा में किसी भी संख्या को बाइनरी रूप में परिवर्तित किया जा सकता है। ऐसा करने के लिए, आपको रैपर कक्षाओं का उपयोग करने की आवश्यकता है। उदाहरण के लिए, यहां बताया गया है कि आप इसे int के लिए कैसे कर सकते हैं :

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(Integer.toBinaryString(x));
   }
}

कंसोल आउटपुट: 101010110 1010 10110 (मैंने इसे पढ़ने में आसान बनाने के लिए स्थान जोड़ा) दशमलव प्रणाली में संख्या 342 है। हमने वास्तव में इस संख्या को अलग-अलग बिट्स में तोड़ दिया है: शून्य और एक। बिट्स पर की जाने वाली क्रियाओं को बिटवाइज़ कहा जाता है ।

• ~ - बिटवाइज़ नहीं।

यह ऑपरेटर बहुत सरल है: यह हमारी संख्या के प्रत्येक बिट के ऊपर से गुजरता है, और बिट को फ़्लिप करता है: शून्य एक हो जाता है, और एक शून्य बन जाता है। यदि हम इसे अपनी संख्या 342 पर लागू करते हैं, तो यहां क्या होता है: 101010110 342 है जिसे बाइनरी संख्या के रूप में दर्शाया गया है 010101001 अभिव्यक्ति का मूल्य है ~342 आइए इसे व्यवहार में लाने का प्रयास करें:

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(~x);
   }
}

कंसोल आउटपुट: 169 169 परिचित, दशमलव प्रणाली में हमारा परिणाम ( 010101001 ) है :)

• & - बिटवाइज़ AND

जैसा कि आप देख सकते हैं, यह काफी हद तक तार्किक AND ( && ) के समान दिखता है। आपको याद होगा कि && ऑपरेटर तभी सही रिटर्न देता है जब दोनों ऑपरेंड सही हों । बिटवाइज़ और इसी तरह से काम करता है: यह दो नंबरों की तुलना थोड़ा-थोड़ा करके करता है। तुलना एक तीसरी संख्या उत्पन्न करती है। उदाहरण के लिए, संख्या 277 और 432 लेते हैं: 110110000 है 277 को बाइनरी संख्या के रूप में दर्शाया गया है 1000101011 है 432 को बाइनरी संख्या के रूप में दर्शाया गया है । क्योंकि यह एक AND ऑपरेटर है, परिणाम केवल 1 होगा यदि दोनों बिट 1 हैं। किसी अन्य स्थिति में, परिणाम 0. 100010101 & है& ऑपरेटर सबसे पहले, हम दो नंबरों के पहले बिट्स की तुलना करते हैं, फिर दूसरे बिट्स, फिर तीसरे और इसी तरह। जैसा कि आप देख सकते हैं, केवल दो मामलों में 1 (पहले और पांचवें बिट) के बराबर संख्या में दोनों संबंधित बिट्स हैं। अन्य सभी तुलनाओं ने 0 का उत्पादन किया। तो अंत में हमें संख्या 10001000 मिली। दशमलव प्रणाली में, यह संख्या 272 से मेल खाती है। आइए देखें:

public class Main {

   public static void main(String[] args) {
       System.out.println(277&432);
   }
}

कंसोल आउटपुट: 272

• | - बिटवाइज़ या।

यह ऑपरेटर उसी तरह काम करता है: दो नंबरों की बिट दर बिट तुलना करना। केवल अब यदि कम से कम एक बिट 1 है, तो परिणाम 1 है। आइए समान संख्याओं (277 और 432) को देखें: 100010101 | 110110000 _______________ 110110101 - का परिणाम | ऑपरेटर यहां हमें एक अलग परिणाम मिलता है: केवल बिट्स जो शून्य रहते हैं वे बिट्स हैं जो दोनों संख्याओं में शून्य थे। नतीजा संख्या 110110101 है। दशमलव प्रणाली में, यह संख्या 437 से मेल खाती है आइए देखें:

public class Main {

   public static void main(String[] args) {
       System.out.println(277|432);
   }
}

कंसोल आउटपुट: 437 हमने सब कुछ सही ढंग से गणना की! :)

• ^ - बिटवाइज़ XOR (एक्सक्लूसिव OR)

हम अभी तक इस ऑपरेटर से नहीं मिले हैं। लेकिन इसमें कुछ भी जटिल नहीं है। यह साधारण OR ऑपरेटर के समान है। एक अंतर है: यदि कम से कम एक ऑपरेंड सत्य है तो सामान्य OR सत्य लौटाता है। लेकिन यह एक होना जरूरी नहीं है: यदि दोनों ऑपरेंड सत्य हैं, तो परिणाम सत्य है। लेकिन एक्सक्लूसिव OR केवल तभी सही होता है जब ऑपरेंड में से कोई एक सत्य हो। यदि दोनों ऑपरेंड सत्य हैं, तो साधारण OR रिटर्न ट्रू ("कम से कम एक ट्रू") देता है, लेकिन XOR गलत रिटर्न देता है। इसलिए इसे एक्सक्लूसिव OR कहा जाता है। यह जानने के बाद कि पिछले बिटवाइज़ ऑपरेटर कैसे काम करते हैं, आप शायद आसानी से 277 ^ 432 की गणना कर सकते हैं ।संचालिका यह हमारा परिणाम है। वे बिट्स जो दोनों संख्याओं में समान थे, एक 0 उत्पन्न करते हैं (जिसका अर्थ है "केवल एक" परीक्षण विफल)। लेकिन जिन बिट्स ने 0-1 या 1-0 की जोड़ी बनाई वे एक हो गए। हमारा परिणाम संख्या 010100101 है। दशमलव प्रणाली में, यह संख्या 165 से मेल खाती है। आइए देखें कि हमारी गणना सही है या नहीं:

public class Main {

   public static void main(String[] args) {
       System.out.println(277^432);
   }
}

कंसोल आउटपुट: 165 सुपर! सब कुछ वैसा ही है जैसा हमने सोचा :) अब बिट शिफ्ट ऑपरेटरों से परिचित होने का समय आ गया है। नाम ही अपने में काफ़ी है। हम कुछ संख्या लेते हैं, और इसके बिट्स को बाएँ या दाएँ घुमाते हैं :) आइए देखें कि यह कैसा दिखता है:

शिफ्ट बाएँ

बिट्स के बाईं ओर शिफ्ट को << द्वारा इंगित किया गया है , यहां एक उदाहरण दिया गया है:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(Integer.toBinaryString(x));
       System.out.println(Integer.toBinaryString(z));
   }
}

इस उदाहरण में, संख्या x = 64 को मान कहा जाता है। यह मूल्य के टुकड़े हैं जिन्हें हम स्थानांतरित करेंगे। हम बिट्स को बाईं ओर शिफ्ट करेंगे (आप << ऑपरेटर की दिशा से इसका अनुमान लगा सकते थे ) बाइनरी सिस्टम में, संख्या 64 = 1000000 संख्या y = 3 को शिफ्ट दूरी कहा जाता है। शिफ्ट दूरी इंगित करती है कि आप संख्या x के बिट्स को दाएं/बाएं कितने बिट्स में स्थानांतरित करना चाहते हैं, हमारे उदाहरण में, हम उन्हें बाईं ओर 3 बिट्स स्थानांतरित करेंगे। शिफ्ट प्रक्रिया को और अधिक स्पष्ट रूप से देखने के लिए, चित्र को देखें। इस उदाहरण में, हम int s का उपयोग करते हैं। कंप्यूटर की मेमोरी में Ints 32 बिट्स पर कब्जा कर लेता है। हमारी मूल संख्या 64 इस प्रकार दिखती है: और अब हम अपने प्रत्येक बिट को लेते हैं और शाब्दिक रूप से उन्हें बाईं ओर 3 स्थानों पर स्थानांतरित करते हैं: हमें जो मिला है, उस पर एक नज़र डालें। जैसा कि आप देख सकते हैं, हमारे सभी बिट स्थानांतरित हो गए हैं, और सीमा के किनारे से अन्य 3 शून्य जोड़े गए हैं। तीन, क्योंकि हम 3 से शिफ्ट हुए हैं। अगर हम 10 से शिफ्ट होते, तो 10 शून्य जुड़ जाते। इस प्रकार, अभिव्यक्ति x << y का अर्थ है "संख्या x के बिट्स को y स्थानों से बाईं ओर स्थानांतरित करें"। हमारी अभिव्यक्ति का परिणाम 1000000000 की संख्या है, जो दशमलव प्रणाली में 512 है। की जाँच करें:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

कंसोल आउटपुट: 512 स्पॉट ऑन! सैद्धांतिक रूप से, बिट्स को अंतहीन रूप से स्थानांतरित किया जा सकता है, लेकिन क्योंकि हमारी संख्या int है , हमारे पास केवल 32 बाइनरी अंक उपलब्ध हैं। इनमें से 7 पर पहले से ही 64 (1000000) का कब्जा है। इसलिए, यदि हम 27 स्थानों को बाईं ओर स्थानांतरित करते हैं, तो हमारा केवल एक डेटा प्रकार की सीमा से आगे बढ़ जाएगा और खो जाएगा। केवल शून्य रह जाएगा!

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 26;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

कंसोल आउटपुट: 0 उम्मीद के मुताबिक, 32 उपलब्ध बिट्स से आगे निकल गया और गायब हो गया। हम एक 32-बिट संख्या के साथ समाप्त हुए जिसमें केवल शून्य शामिल थे। स्वाभाविक रूप से, यह दशमलव प्रणाली में 0 से मेल खाती है। बाईं ओर की शिफ्ट को याद रखने का एक सरल नियम है: बाईं ओर की प्रत्येक शिफ्ट के लिए, संख्या को 2 से गुणा किया जाता है। आइए बिट्स के चित्रों के बिना निम्नलिखित अभिव्यक्ति की गणना करने का प्रयास करें 111111111 << 3 हमें संख्या 111111111 को 2 से गुणा करने की आवश्यकता है । नतीजतन, हमें 888888888 मिलता है। आइए कुछ कोड लिखें और जांचें:

public class Main {

   public static void main(String[] args) {
       System.out.println(111111111 << 3);
   }
}

कंसोल आउटपुट: 888888888

दाएं शिफ्ट करें

इस ऑपरेशन को >> द्वारा दर्शाया गया है । यह वही काम करता है, लेकिन दूसरी दिशा में! :) हम पहिए का पुन: आविष्कार नहीं करेंगे। आइए इसे उसी int 64 के साथ आज़माएं।

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 2;// Shift distance

       int z = (x >> y);
       System.out.println(z);
   }
}

2 से दाईं ओर शिफ्ट होने के परिणामस्वरूप, हमारी संख्या में दो चरम शून्य सीमा से बाहर चले जाते हैं और खो जाते हैं। हमें 10000 मिलता है, जो दशमलव सिस्टम कंसोल आउटपुट में संख्या 16 से मेल खाता है: 16 दाईं ओर की शिफ्ट को याद रखने का एक सरल नियम है: प्रत्येक शिफ्ट को दाईं ओर दो से विभाजित किया जाता है, किसी भी शेष को छोड़ दिया जाता है। उदाहरण के लिए, 35 >> 2 का अर्थ है कि हमें 35 को 2 से दो बार विभाजित करने की आवश्यकता है, शेषफल 35/2 = 17 (शेष 1 को छोड़ दें) 17/2 = 8 (शेष 1 को छोड़ दें) अंत में, 35 >> 2 को चाहिए 8 के बराबर हो। आइए देखें:

public class Main {

   public static void main(String[] args) {
       System.out.println(35 >> 2);
   }
}

कंसोल आउटपुट: 8

जावा में ऑपरेटर की प्राथमिकता

कोड लिखते और पढ़ते समय, आपको अक्सर ऐसे एक्सप्रेशन मिलेंगे जो कई ऑपरेशनों को जोड़ते हैं। यह समझना बहुत महत्वपूर्ण है कि उन्हें किस क्रम में निष्पादित किया जाएगा (अन्यथा, आप परिणाम से आश्चर्यचकित हो सकते हैं) क्योंकि जावा में बहुत सारे ऑपरेशन हैं, उनमें से प्रत्येक को एक विशेष तालिका में एक स्थान दिया गया है:

संचालक वरीयता

सभी ऑपरेशन उनकी प्राथमिकता को ध्यान में रखते हुए बाएं से दाएं किए जाते हैं। उदाहरण के लिए, यदि हम लिखते हैं

int x  = 6 - 4/2;

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

int x  = (6 - 4)/2;

तब घटाव पहले किया जाता है, क्योंकि यह कोष्ठकों में संलग्न है। तार्किक && ऑपरेटर की पूर्वता अपेक्षाकृत कम है (तालिका देखें), इसलिए यह आमतौर पर अंतिम होगी। उदाहरण के लिए:

boolean x = 6 - 4/2 > 3 && 12*12 <= 119;

इस अभिव्यक्ति को निम्नानुसार क्रियान्वित किया जाएगा:

• 4/2 = 2

boolean x = 6 - 2 > 3 && 12*12 <= 119;

• 12*12 = 144

boolean x = 6 - 2 > 3 && 144 <= 119;

• 6-2 = 4

boolean x = 4 > 3 && 144 <= 119;

अगला, तुलना ऑपरेटरों को निष्पादित किया जाता है:

• 4 > 3 = सत्य

boolean x = true && 144 <= 119;

• 144 <= 119 = असत्य

boolean x = true && false;

और, अंत में, AND ऑपरेटर ( && ) को अंतिम रूप से निष्पादित किया जाएगा।

boolean x = true && false;
boolean x = false;

उदाहरण के लिए, जोड़ ( + ) ऑपरेटर की प्राथमिकता != (बराबर नहीं) तुलना ऑपरेटर से अधिक है ; इसलिए, अभिव्यक्ति में

boolean x = 7 != 6+1;

6+1 ऑपरेशन पहले किया जाएगा, फिर 7!= 7 चेक (जो असत्य का मूल्यांकन करता है), और अंत में परिणाम का असाइनमेंट (गलत) वेरिएबल x (असाइनमेंट में आमतौर पर सभी ऑपरेटरों की सबसे कम प्राथमिकता होती है; देखें टेबल)। काहे! यह एक बहुत बड़ा सबक था, लेकिन आपने कर दिखाया! यदि आप इनमें से कुछ या पिछले पाठों को पूरी तरह से नहीं समझ पाए हैं, तो चिंता न करें। हम भविष्य में इन विषयों पर एक से अधिक बार बात करेंगे। तार्किक और संख्यात्मक संक्रियाओं के बारे में कुछ CodeGym पाठ। हम इन तक जल्दी नहीं पहुंचेंगे, लेकिन अब इन्हें पढ़ने में कोई हर्ज नहीं है।