Java Bitwise آپريٽرز

اڄ جي سبق ۾، اسان جاوا Bitwise آپريٽرز سان واقف ٿينداسين ۽ مثالن تي غور ڪنداسين ته انهن سان ڪيئن ڪم ڪجي. توهان شايد لفظ "بٽ" کان واقف آهيو. جيڪڏهن نه، اچو ته ياد ڪريون ته ان جو مطلب ڇا آهي :) بٽ ڪمپيوٽر ۾ معلومات جو ننڍڙو يونٽ آهي. ان جو نالو بائنري عددن مان اچي ٿو . ٿلهي کي ٻن انگن مان هڪ سان ظاهر ڪري سگهجي ٿو: 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 نه.

هي آپريٽر تمام سادو آهي: اهو اسان جي نمبر جي هر هڪ بٽ مٿان گذري ٿو، ۽ سا کي ڦٽو ڪري ٿو: صفر بڻجي وڃن ٿا، ۽ اهي صفر بڻجي وڃن ٿا. جيڪڏهن اسان ان کي پنهنجي نمبر 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 - جو نتيجو | operator هتي اسان کي هڪ مختلف نتيجو ملي ٿو: صرف اهي بٽ جيڪي صفر رهندا آهن اهي بٽ آهن جيڪي ٻنهي نمبرن ۾ صفر هئا. نتيجو نمبر 110110101 آهي. ڊيسيمل سسٽم ۾، اهو نمبر 437 سان ملندو آهي اچو ته ڏسو:

public class Main {

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

ڪنسول آئوٽ: 437 اسان سڀ ڪجهه صحيح حساب ڪيو! :)

• ^ - bitwise XOR (خاص يا)

اسان اڃا تائين هن آپريٽر سان نه مليا آهيون. پر ان ۾ ڪا به پيچيدگي ناهي. اهو عام يا آپريٽر وانگر آهي. ھڪڙو فرق آھي: عام OR واپسي صحيح آھي جيڪڏھن گھٽ ۾ گھٽ ھڪڙو اوپيرينڊ سچو آھي. پر اهو ضروري ناهي ته هڪ هجي: جيڪڏهن ٻئي آپريشن صحيح آهن، نتيجو صحيح آهي. پر خاص OR سچو موٽندو صرف ان صورت ۾ جڏهن عملن مان هڪ صحيح آهي. جيڪڏهن ٻئي آپرينڊ سچا آهن، عام OR واپسي سچو ("گهٽ ۾ گهٽ هڪ سچو")، پر XOR غلط موٽائي ٿو. ان ڪري ان کي خاص OR سڏيو ويندو آهي. ڄاڻو ته اڳوڻو 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;//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-bit نمبر سان ختم ڪيو جنهن ۾ صرف صفر شامل آهن. قدرتي طور تي، اهو ملندو آهي 0 ڊسيمل سسٽم ۾. هتي کاٻي پاسي کان ياد رکڻ لاء هڪ سادو قاعدو آهي نتيجي طور، اسان کي 888888888 ملي ٿو. اچو ته ڪجهه ڪوڊ لکون ۽ چيڪ ڪريو:

public class Main {

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

ڪنسول آئوٽ: 888888888

ساڄي طرف ڦيرايو

هن آپريشن جي نشاندهي ڪئي وئي آهي >> . اهو ساڳيو ڪم ڪري ٿو، پر ٻئي طرف! :) اسان ڦيٿي reinvent نه ڪندو. اچو ته ان کي ساڳي 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 ڏانهن (اسائنمينٽ کي عام طور تي سڀني آپريٽرن کان گهٽ ترجيح هوندي آهي ؛ ڏسو ميز). اڙي! اهو هڪ وڏو سبق هو، پر توهان اهو ڪيو! جيڪڏهن توهان هن يا پوئين سبق مان ڪجهه مڪمل طور تي نه سمجهي، پريشان نه ڪريو. اسان مستقبل ۾ انهن موضوعن تي هڪ کان وڌيڪ ڀيرا رابطو ڪنداسين. منطقي ۽ عددي عملن بابت ڪجھ ڪوڊ گيم سبق. اسان انهن کي ڪنهن به وقت جلدي حاصل نه ڪنداسين، پر هاڻي توهان کي پڙهڻ ۾ ڪو به نقصان نه آهي.