جاوا ۾ Bitwise آپريشن

توھان شايد لفظ "بيٽ" کان واقف آھيو. جيڪڏهن نه، اچو ته ان کي ڄاڻون :) هڪ بٽ ڪمپيوٽر ۾ معلومات جي ماپ جو گهٽ ۾ گهٽ يونٽ آهي. ان جو نالو انگريزي " binary digit " - "binary number" مان آيو آهي. ٿلهي کي ٻن انگن مان هڪ طور ظاهر ڪري سگهجي ٿو: 1 يا 0. هتي هڪ خاص نمبر سسٽم آهي جيڪو هڪ ۽ صفر تي ٻڌل آهي - بائنري. اسان رياضي جي جنگل ۾ نه وينداسين ۽ صرف ياد رکو ته جاوا ۾ ڪنهن به نمبر کي ان جي بائنري شڪل ۾ تبديل ڪري سگهجي ٿو. هن کي ڪرڻ لاء، توهان کي استعمال ڪرڻ جي ضرورت آهي wrapper طبقن. مثال طور، هتي آهي اهو ڪيئن ڪجي هڪ نمبر لاءِ 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 پر جيئن ته هڪ int متغير 4 بائيٽ وٺندو آهي، يعني. 32 بٽ، حقيقت ۾، متغير ۾ نمبر هن طرح محفوظ ٿيل آهي: 00000000 00000000 00000001 01010110- جاوا ۾ int جي قسم جي متغير ۾ 342 نمبر 11111111 11111111 11111110 10101001- java ۾ ~ 342 جي اظهار جو نتيجو، اچو ته هن کي عملي طور تي ڪرڻ جي ڪوشش ڪريون:

public class Main {

   public static void main(String[] args) {

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

ڪنسول آئوٽ:

11111111111111111111111010101001

• &- bitwise آپريٽر "AND"

جئين توهان ڏسي سگهو ٿا، اهو منطقي "AND" ( &&) سان بلڪل ملندڙ جلندڙ آهي. آپريٽر &&، جيئن توهان کي ياد آهي، واپسي trueصرف ان صورت ۾ جڏهن ٻئي آپرينڊ صحيح آهن. Bitwise &ساڳئي طريقي سان ڪم ڪري ٿو: اهو ٻن نمبرن کي ڀيٽ ڪري ٿو. هن مقابلي جو نتيجو ٽيون نمبر آهي. مثال طور، اچو ته نمبر 277 ۽ 432 وٺون: 100010101 - نمبر 277 بائنري فارم ۾ 110110000 - نمبر 432 بائنري فارم ۾ اڳيون، آپريٽر &مٿين نمبر جي پهرين بٽ کي هيٺين نمبر جي پهرين بٽ سان گڏ ڪري ٿو. جيئن ته هي هڪ "AND" آپريٽر آهي، نتيجو صرف 1 جي برابر هوندو جڏهن ٻئي بٽ 1 جي برابر هوندا. ٻين سڀني صورتن ۾، نتيجو ٿيندو 0. 100010101 & 110110000 _______________ 100010000 - ڪم جو نتيجو & اسان پهريون ڀيرو پهرين بٽس جو مقابلو ڪندا آهيون. ٻن عددن جو هڪ ٻئي سان، پوءِ ٻيو بٽ، ٽيون، وغيره. جئين توهان ڏسي سگهو ٿا، صرف ٻن ڪيسن ۾ ٻنهي بٽ نمبرن ۾ 1 جي برابر هئا (پهريون ۽ پنجون بٽ). ٻين سڀني موازن جو نتيجو 0 هو. ان ڪري، آخر ۾ اسان کي 100010000 نمبر مليو. ڊيسيمل سسٽم ۾، اهو نمبر 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 exclusive OR (پڻ XOR طور سڃاتو وڃي ٿو)

اسان اڳ ڪڏهن به اهڙو آپريٽر نه ڏٺو آهي. پر ان ۾ ڪا به پيچيدگي نه آهي. اهو هڪ باقاعده "يا" وانگر ڏسڻ ۾ اچي ٿو. فرق ھڪڙو آھي: عام "يا" موٽندو آھي trueجيڪڏھن گھٽ ۾ گھٽ ھڪڙو ڪم صحيح آھي. پر ضروري ناهي ته هڪ هجي - جيڪڏهن ٻئي آهن true- پوء نتيجو true. پر خاص "يا" موٽائي ٿو trueصرف ان صورت ۾ جڏهن ڪمن مان هڪ صحيح آهي. جيڪڏهن ٻئي عمل صحيح آهن، هڪ باقاعده "يا" واپس ايندو true("گهٽ ۾ گهٽ هڪ صحيح آهي")، پر هڪ خاص يا واپس ايندو false. ان ڪري ان کي خاص سڏيو ويندو آهي. پوئين bitwise عملن جي اصول کي ڄاڻڻ سان، توھان شايد آساني سان 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;//meaning
       int y = 3;//quantity

       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. Intڪمپيوٽر جي ميموري جي 32 بٽس تي قبضو ڪري ٿو. اھو اھو آھي جيڪو اسان جو اصل نمبر 64 ڏسڻ ۾ اچي ٿو: ۽ ھاڻي اسين، لفظ جي لفظي معنى ۾، پنھنجي ھر بٽ کي وٺون ٿا ۽ ان کي کاٻي طرف 3 سيلز ذريعي ڦيرايو: اھو اھو آھي جيڪو اسان حاصل ڪيو. جئين توهان ڏسي سگهو ٿا، اسان جا سڀئي بٽ منتقل ٿي ويا آهن، ۽ 3 وڌيڪ صفر شامل ڪيا ويا آهن حد کان ٻاهر. 3 - ڇاڪاڻ ته اسان 3 ذريعي شفٽ ٿي رهيا هئاسين. جيڪڏهن اسان 10 ذريعي شفٽ ڪري رهيا هئاسين، 10 صفر شامل ڪيا ويندا. تنهن ڪري اظهار x << yجو مطلب آهي "هڪ نمبر y سيلن جي بٽس کي хکاٻي طرف منتقل ڪريو." اسان جي اظهار جو نتيجو نمبر 1000000000 هو، جيڪو ڊيسيمل سسٽم ۾ 512 جي برابر آهي. اچو ته چيڪ ڪريون:

public class Main {

   public static void main(String[] args) {
       int x = 64;//meaning
       int y = 3;//quantity

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

ڪنسول آئوٽ:

512

اهو درست آهي! نظريي ۾، بٽ کي غير يقيني طور تي منتقل ڪري سگھجي ٿو. پر جيئن ته اسان وٽ نمبر آهي int، اتي صرف 32 سيل موجود آهن. انهن مان، 7 اڳ ۾ ئي 64 نمبر (1,000,000) جي قبضي ۾ آهن. تنهن ڪري، جيڪڏهن اسان ٺاهيو، مثال طور، کاٻي طرف 27 شفٽون، اسان جو واحد يونٽ حد کان ٻاهر نڪري ويندو ۽ "اوور رائٽ" ٿيندو. صرف صفر باقي رهندو!

public class Main {

   public static void main(String[] args) {
       int x = 64;//meaning
       int y = 26;//quantity

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

ڪنسول آئوٽ:

0

جيئن اسان توقع ڪئي، ھڪڙو 32 بٽ سيلز کان ٻاھر ويو ۽ غائب ٿي ويو. اسان هڪ 32-bit نمبر حاصل ڪيو جنهن ۾ صرف صفر شامل آهن. قدرتي طور، ڊيسيمل سسٽم ۾ اهو 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;//meaning
       int y = 2;//quantity

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

2 کان ساڄي طرف شفٽ ٿيڻ جي نتيجي ۾، اسان جي نمبر جا ٻه انتهائي صفر حد کان ٻاهر ويا ۽ ختم ٿي ويا. اسان کي 10000 نمبر مليو، جيڪو ڊيسيمل سسٽم ۾ نمبر 16 سان ملندو آهي. ڪنسول ڏانهن آئوٽ:

16

ساڄي شفٽ کي ياد رکڻ لاءِ هڪ سادي اصول: هر ساڄي شفٽ ٻن طرفن ۾ ورهائجي، باقي ڪنهن کي رد ڪندي. مثال طور، 35 >> 2 ان جو مطلب اهو آهي ته اسان کي 35 کي 2 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 = true

  boolean x = true && 144 <= 119;

• 144 <= 119 = false

  boolean x = true && false;

• ۽ آخرڪار، آخري آپريٽر تي عمل ڪيو ويندو &&.

  boolean x = true && false;

  boolean x = false;

  اضافي آپريٽر ( +) مثال طور، مقابلي واري آپريٽر جي ڀيٽ ۾ وڌيڪ ترجيح آهي !=("برابر نه")؛

  تنهن ڪري اظهار ۾:

  boolean x = 7 != 6+1;

  پهرين آپريشن 6+1 ڪيو ويندو، پوءِ چيڪ ڪيو ويندو 7!=7 (غلط)، ۽ آخر ۾ نتيجو falseمتغير کي لڳايو ويندو x. تفويض عام طور تي سڀني عملن جي گھٽ ترجيح آھي - ٽيبل ۾ ڏسو.

اڙي! اسان جو ليڪچر ڊگهو هو، پر توهان اهو ڪيو! جيڪڏهن توهان هن ۽ پوئين ليڪچر جا ڪجهه حصا مڪمل طور تي نٿا سمجهو، پريشان نه ٿيو، اسان مستقبل ۾ انهن موضوعن تي هڪ کان وڌيڪ ڀيرا رابطو ڪنداسين. هتي توهان لاء ڪجهه مفيد لنڪس آهن:

• منطقي آپريٽرز - جاوا رش ليڪچر منطقي عملن تي. اسان انهن کي ڪنهن به وقت جلدي حاصل نه ڪنداسين، پر توهان انهن کي هاڻي پڙهي سگهو ٿا، ڪو به نقصان نه ٿيندو