جاوا بٹ وائز آپریٹرز

آج کے سبق میں، ہم Java Bitwise آپریٹرز سے واقف ہوں گے اور ان کے ساتھ کام کرنے کے طریقے کی مثالوں پر غور کریں گے۔ آپ شاید لفظ "bit" سے واقف ہوں گے۔ اگر نہیں، تو آئیے یاد کرتے ہیں کہ اس کا کیا مطلب ہے :) بٹ کمپیوٹر میں معلومات کی سب سے چھوٹی اکائی ہے۔ اس کا نام بائنری ہندسے سے آیا ہے ۔ تھوڑا سا دو نمبروں میں سے کسی ایک سے ظاہر کیا جا سکتا ہے: 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 ہے۔ ہم نے اصل میں اس نمبر کو انفرادی بٹس میں توڑ دیا ہے: صفر اور ایک۔ بٹس پر کیے جانے والے آپریشنز کو bitwise کہا جاتا ہے ۔

• ~ - bitwise NOT.

یہ آپریٹر بہت آسان ہے: یہ ہمارے نمبر کے ہر بٹ پر سے گزرتا ہے، اور تھوڑا سا پلٹتا ہے: صفر ایک بن جاتا ہے، اور صفر بن جاتا ہے۔ اگر ہم اسے اپنے نمبر 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 ( && ) سے کافی ملتا جلتا نظر آتا ہے۔ && آپریٹر، آپ کو یاد ہو گا، صرف درست لوٹاتا ہے اگر دونوں آپرینڈز درست ہوں ۔ Bitwise اور اسی طرح کام کرتا ہے: یہ دو نمبروں کا تھوڑا سا موازنہ کرتا ہے۔ موازنہ ایک تیسرا نمبر پیدا کرتا ہے۔ مثال کے طور پر، آئیے نمبرز 277 اور 432 کو لیتے ہیں: 110110000 ہے 277 کو بائنری نمبر کے طور پر دکھایا گیا ہے 1000101011 ہے 432 کو بائنری نمبر کے طور پر دکھایا گیا ہے اگلا، آپریٹر اوپری نمبر کے پہلے بٹ کا نیچے والے نمبر کے پہلے بٹ سے موازنہ کرتا ہے۔ کیونکہ یہ ایک AND آپریٹر ہے، نتیجہ صرف 1 ہوگا اگر دونوں بٹس 1 ہوں۔ کسی بھی دوسری صورت میں، نتیجہ 0 ہے۔ 100010101 اور 110110000 _______________ 10001000 - & آپریٹر کا نتیجہ پہلے، ہم دونوں کے پہلے بٹس کا موازنہ کرتے ہیں۔ نمبرز، پھر دوسرے بٹس، پھر تیسرا، وغیرہ۔ جیسا کہ آپ دیکھ سکتے ہیں، صرف دو صورتوں میں 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 - کا نتیجہ | آپریٹر یہاں ہمیں ایک مختلف نتیجہ ملتا ہے: صرف وہ بٹس جو صفر رہ جاتے ہیں وہ بٹس ہیں جو دونوں نمبروں میں زیرو تھے۔ نتیجہ نمبر 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 غلط لوٹاتا ہے۔ اسی لیے اسے exclusive OR کہا جاتا ہے۔ یہ جانتے ہوئے کہ پچھلے بٹ وائز آپریٹرز کیسے کام کرتے ہیں، آپ شاید آسانی سے 277 ^ 432 کا حساب لگا سکتے ہیں۔ لیکن آئیے اس میں ایک بار پھر کھودتے ہیں :) 100010101 ^ 110110000 _______________ 010100101 - ^ آپریٹر کا نتیجہ یہ ہمارا نتیجہ ہے۔ وہ بٹس جو دونوں نمبروں میں ایک جیسے تھے ایک 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 (بقیہ کو ضائع کریں) 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 کے کچھ اسباق۔ ہم جلد ہی ان تک نہیں پہنچیں گے، لیکن اب آپ کے پڑھنے میں کوئی حرج نہیں ہے۔