Java Bitwise ऑपरेटर

आजच्या धड्यात, आम्ही Java Bitwise ऑपरेटर्सशी परिचित होऊ आणि त्यांच्यासोबत कसे कार्य करावे याच्या उदाहरणांचा विचार करू. आपण कदाचित "बिट" शब्दाशी परिचित आहात. नसल्यास, याचा अर्थ काय ते आठवू या :) बिट हे संगणकातील माहितीचे सर्वात लहान एकक आहे. त्याचे नाव बायनरी अंकावरून आले आहे . बिट दोनपैकी एकाने व्यक्त केले जाऊ शकते: 1 किंवा 0. एक आणि शून्यावर आधारित एक विशेष बायनरी संख्या प्रणाली आहे. आम्ही इथे गणिताच्या जंगलात जाणार नाही. आम्ही फक्त लक्षात ठेवू की Java मधील कोणतीही संख्या बायनरी स्वरूपात रूपांतरित केली जाऊ शकते. हे करण्यासाठी, आपल्याला आवरण वर्ग वापरण्याची आवश्यकता आहे. उदाहरणार्थ, int साठी तुम्ही हे कसे करू शकता ते येथे आहे :

public class Main {

   public static void main(String[] args) {

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

कन्सोल आउटपुट: 101010110 1010 10110 (मी वाचणे सोपे करण्यासाठी जागा जोडली आहे) दशांश प्रणालीमध्ये 342 क्रमांक आहे. आम्ही ही संख्या प्रत्यक्षात वैयक्तिक बिट्समध्ये मोडली आहे: शून्य आणि एक. बिट्सवर केलेल्या ऑपरेशन्सना बिटवाइज म्हणतात .

• ~ - bitwise नाही.

हा ऑपरेटर अगदी सोपा आहे: तो आमच्या नंबरच्या प्रत्येक बिटवरून जातो आणि थोडासा पलटतो: शून्य एक होतात आणि शून्य होतात. जर आपण ते आमच्या क्रमांक 342 वर लागू केले, तर काय होते ते येथे आहे: 101010110 हे 342 बायनरी क्रमांक म्हणून दर्शविले जाते 010101001 हे अभिव्यक्तीचे मूल्य आहे ~342 चला हे व्यवहारात आणण्याचा प्रयत्न करूया:

public class Main {

   public static void main(String[] args) {

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

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

• & - bitwise AND

तुम्ही बघू शकता, ते तार्किक AND ( && ) सारखे दिसते . && ऑपरेटर , तुम्हाला आठवत असेल, दोन्ही ऑपरेंड्स सत्य असल्यासच खरे परत येतात. बिटवाइज आणि सारख्याच प्रकारे कार्य करते: ते दोन संख्यांची थोडी-थोडी तुलना करते. तुलना तिसऱ्या क्रमांकाची निर्मिती करते. उदाहरणार्थ, संख्या 277 आणि 432 घेऊ: 110110000 म्हणजे 277 बायनरी संख्या म्हणून दर्शविले जाते 1000101011 आहे 432 बायनरी संख्या म्हणून प्रस्तुत केले जाते पुढे, ऑपरेटर आणि वरच्या संख्येच्या पहिल्या बिटची तुलना खालच्या क्रमांकाच्या पहिल्या बिटशी करतो. कारण हा AND ऑपरेटर आहे, दोन्ही बिट 1 असल्यासच परिणाम 1 असेल. इतर कोणत्याही बाबतीत, परिणाम 0. 100010101 आणि& operator प्रथम, आम्ही दोन संख्यांच्या पहिल्या बिट्सची, नंतर दुसऱ्या बिट्सची, नंतर तिसरीची तुलना करतो. तुम्ही बघू शकता, फक्त दोन प्रकरणांमध्ये 1 (पहिला आणि पाचवा बिट्स) च्या बरोबरीच्या संख्येतील दोन्ही संबंधित बिट्स आहेत. इतर सर्व तुलना 0s तयार केल्या. तर शेवटी आम्हाला 10001000 ही संख्या मिळाली. दशांश प्रणालीमध्ये, ती संख्या 272 शी संबंधित आहे. चला तपासूया:

public class Main {

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

कन्सोल आउटपुट: 272

• | - bitwise OR.

हा ऑपरेटर त्याच प्रकारे कार्य करतो: दोन संख्यांची थोडी-थोडी तुलना करणे. फक्त आता जर किमान एक बिट 1 असेल, तर परिणाम 1 असेल. चला समान संख्या (277 आणि 432) पाहू: 100010101 | 110110000 _______________ 110110101 - चा निकाल | operator येथे आम्हाला एक वेगळा निकाल मिळतो: शून्य राहिलेले फक्त बिट्स ते बिट आहेत जे दोन्ही संख्यांमध्ये शून्य होते. परिणाम 110110101 क्रमांक आहे. दशांश प्रणालीमध्ये, ते 437 क्रमांकाशी संबंधित आहे, चला तपासू:

public class Main {

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

कन्सोल आउटपुट: 437 आम्ही सर्वकाही अचूकपणे मोजले! :)

• ^ - bitwise XOR (अनन्य किंवा)

आम्ही अद्याप या ऑपरेटरला भेटलो नाही. पण त्यात काहीही क्लिष्ट नाही. हे सामान्य OR ऑपरेटरसारखेच आहे. एक फरक आहे: सामान्य OR कमीत कमी एक ऑपरेंड सत्य असल्यास सत्य परत करतो. परंतु ते एक असण्याची गरज नाही: जर दोन्ही ऑपरेंड्स सत्य असतील, तर परिणाम सत्य आहे. परंतु केवळ एक ऑपरेंड सत्य असेल तरच exclusive OR खरे मिळवते. दोन्ही ऑपरेंड सत्य असल्यास, सामान्य OR खरे ("किमान एक सत्य") परत करतो, परंतु XOR खोटे परत करतो. म्हणूनच याला अनन्य OR म्हणतात. मागील बिटवाइज ऑपरेटर्स कसे कार्य करतात हे जाणून घेतल्यास, आपण कदाचित सहजपणे 277 ^ 432 ची गणना करू शकता. परंतु आपण त्यात आणखी एकदा शोधू या :) 100010101 ^ 110110000 _______________ 010100101 - ^ चा परिणामऑपरेटर हा आमचा निकाल आहे. दोन्ही संख्यांमध्ये समान असलेले बिट 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

Java मध्ये ऑपरेटर प्राधान्य

कोड लिहिताना आणि वाचताना, तुम्हाला अनेकदा अनेक क्रिया एकत्रित करणारे अभिव्यक्ती आढळतील. ते कोणत्या क्रमाने अंमलात आणले जातील हे समजून घेणे खूप महत्वाचे आहे (अन्यथा, परिणामामुळे तुम्हाला आश्चर्य वाटेल) कारण Java मध्ये बरीच ऑपरेशन्स आहेत, त्या प्रत्येकाला एका विशेष टेबलमध्ये स्थान नियुक्त केले आहे:

ऑपरेटर प्राधान्य

सर्व ऑपरेशन्स डावीकडून उजवीकडे केली जातात, त्यांची प्राधान्ये लक्षात घेऊन. उदाहरणार्थ, जर आपण लिहितो

int x  = 6 - 4/2;

नंतर विभागणी ऑपरेशन ( 4/2 ) प्रथम केले जाईल. तो दुसरा आला असला तरी त्याला जास्त प्राधान्य आहे. कंस आणि कंस कमाल प्राधान्य दर्शवतात. तुम्हाला कदाचित शाळेपासून ते आठवत असेल. उदाहरणार्थ, आपण त्यांना अभिव्यक्तीमध्ये जोडल्यास

int x  = (6 - 4)/2;

नंतर वजाबाकी प्रथम केली जाते, कारण ती कंसात बंद असते. लॉजिकल && ऑपरेटरची प्राथमिकता कमी आहे (टेबल पहा), त्यामुळे ते सहसा शेवटचे असेल. उदाहरणार्थ:

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

ही अभिव्यक्ती खालीलप्रमाणे कार्यान्वित केली जाईल:

• ४/२ = २

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

• १२*१२ = १४४

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

• ६-२ = ४

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 (असाइनमेंटला सर्व ऑपरेटर्सपेक्षा सर्वात कमी प्राधान्य असते; पहा टेबल). ओफ्फ! हा एक मोठा धडा होता, पण तुम्ही ते केले! तुम्हाला यापैकी काही किंवा मागील धडे पूर्णपणे समजले नसल्यास, काळजी करू नका. आम्ही भविष्यात या विषयांना एकापेक्षा जास्त वेळा स्पर्श करू. तार्किक आणि संख्यात्मक ऑपरेशन्सबद्दल कोडजिमचे काही धडे. आम्ही लवकरच यांवर पोहोचणार नाही, परंतु आता ते वाचण्यात काहीही नुकसान नाही.