جاوا ۾ منطقي آپريٽرز

• جاوا ۾ منطقي آپريٽرز
• منطقي نفي آپريٽر!
• منطقي ۽ - ۽، گڏوگڏ مشروط AND - &&
• منطقي يا آپريٽر آهي |، گڏوگڏ مشروط يا آپريٽر آهي ||
• XOR - منطقي خاص يا - آپريٽر ^
• منطقي عملن جي ترجيح
• پيچيده منطقي اظهار
• Bitwise (bitwise) آپريٽرز
• Bitwise آپريٽرز ۽، | ۽ ^
• اضافي ڪوڊ
• Bitwise negation operator ~

جاوا ۾ منطقي آپريشن

منطقي آپريشن Boolean آپريٽرز استعمال ڪندي ڪيا ويا آهن. معاف ڪجو ٽوٽولوجي، پر حقيقت اها آهي ته شيون ڪيئن آهن. بنيادي منطقي عملن (پروگرامنگ ۽ رياضي ۾) منطقي دليلن (آپرينڊز) تي لاڳو ڪري سگھجن ٿا، ۽ پڻ استعمال ڪري سگھجن ٿا وڌيڪ پيچيده اظهار ٺاهڻ لاءِ، جيئن انگن تي رياضياتي عملن وانگر. مثال طور اظهار:

(a | b) | (c < 100) & !(true) ^ (q == 5)

هڪ پيچيده منطقي اظهار آهي جنهن ۾ چار operands آهن: (a | b), where аand bare type variables boolean (c < 100) (true) (q == 5) . بدلي ۾، هڪ سادي منطقي اظهار (a | b)پڻ ٻن آپرينڊ دليلن تي مشتمل آهي. هڪ منطقي عمل هڪ اظهار آهي جنهن کي چئي سگهجي ٿو صحيح يا غلط، صحيح يا غلط . جاوا جي اصطلاح ۾، هڪ بوليان اوپيرينڊ هڪ قسم جو اظهار آهي booleanيا بوليان، مثال طور:

• (2 < 1)- منطقي عمل، ان جو قدر غلط آهي
• true- هڪ منطقي عمل جنهن جي قيمت واضح طور تي صحيح آهي
• boolean a- پڻ ٿي سگهي ٿو هڪ منطقي آپرينڊ، جهڙوڪ Boolean a
• int a = 2- هڪ منطقي عمل نه آهي ، اهو صرف قسم جو هڪ متغير آهيint
• String a = "true"اهو پڻ هڪ منطقي عمل ناهي . هي هڪ اسٽرنگ آهي جنهن جي متن جي قيمت آهي "true".

هيٺيون منطقي عمل جاوا ۾ موجود آهن:

• منطقي نفي ، پڻ سڏيو ويندو آهي NOTinversion. جاوا ۾، اهو اشارو ڪيو ويو آهي " !" علامت کان اڳ operand. ھڪڙي ڪم تي لاڳو ٿئي ٿو.
• منطقي ۽ ، اهو پڻ ANDهڪ گڏيل آهي. &ٻن ڪمرن جي وچ ۾ "" علامت سان اشارو ڪيو ويو آهي جنهن تي اهو لاڳو ٿئي ٿو.
• منطقي يا جاوا ۾ ، اهو پڻ آهي - OR، اهو پڻ disjunction آهي. جاوا ۾، اهو اشارو ڪيو ويو آهي علامت " |" ٻن ڪمرن جي وچ ۾.
• خاص يا , XORسخت اختلاف. جاوا ۾، اهو اشارو ڪيو ويو آهي علامت " ^" ٻن ڪمرن جي وچ ۾.
• جاوا ۾، منطقي آپريٽرز شامل آهن مشروط يا ، بيان ڪيل طور تي ||، انهي سان گڏ مشروط ۽ - &&.

نوٽ: رياضياتي منطق ۾ پڻ اهي برابري جي رشتي تي غور ڪن ٿا، ٻين لفظن ۾، برابري. بهرحال، جاوا ۾، برابري آپريٽر کي==منطقي آپريٽر نه سمجهيو ويندو آهي. ڌيان! جاوا ۾، منطقي آپريٽرز&،|۽^انٽيجرز تي پڻ لاڳو ٿين ٿا. انهي حالت ۾، اهي ٿورو مختلف ڪم ڪن ٿا ۽ انهن کي bitwise (يا bitwise) منطقي آپريٽر سڏيو ويندو آهي. انھن جي باري ۾ - مضمون جي آخر ۾. اچو ته هڪ جدول تي نظر وجهون جن مان هر هڪ جاوا منطقي آپريٽرز جي مختصر وضاحت سان، ۽ هيٺ اسين انهن کي وڌيڪ تفصيل سان بيان ڪنداسين ۽ ڪوڊ جا مثال مهيا ڪنداسين.

منطقي نفي آپريٽر!

هي آپريٽر يونيري آهي، مطلب ته اهو هڪ واحد بولين ايڪسپريس يا اوپيرينڊ تي لاڳو ٿئي ٿو. اهو سمجهڻ بلڪل سادو آهي، ڪنهن به نفي وانگر: آپريٽر صرف اظهار جي معني کي ان جي سامهون تبديل ڪري ٿو. سچائي ٽيبل يا منفي آپريشن ڪرڻ جا نتيجا: مثال. منطقي نفي آپريشن

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       System.out.println(!a); // here our boolean expression reverses its value
       System.out.println(!false); // non-false expression, as you might guess, will be equal to... what?
       System.out.println(!(2 < 5)); // expression (2 < 5) is true, so its negation is false

   }
}

پروگرام جي پيداوار هن ريت هوندي:

false
true
false

منطقي ۽ - ۽، گڏوگڏ مشروط AND - &&

منطقي AND يا ڪنجوڪشن ٻن اظهارن تي لاڳو ٿئي ٿو، ۽ ان جو نتيجو صحيح ٿيندو صرف ان صورت ۾ جڏهن ٻئي operands صحيح آهن. اهو آهي، جيڪڏهن هڪ aيا operands غلطb آهي ، پوء اظهار غلط ٿيندو ، ٻئي آپريٽر جي قيمت کان سواء. جيڪڏهن توهان تصور ڪيو ته صحيح نمبر 1 آهي ۽ غلط آهي 0، ته پوءِ آپريٽر ڪم ڪري ٿو ساڳيو ئي عام ضرب. تنهن ڪري، منطقي ۽ اڪثر سڏيو ويندو آهي "منطقي ضرب." ۽، رستي جي ذريعي، هي حقيقت مدد ڪري ٿي جلدي ياد ڪرڻ جي آپريٽر جي آپريشن ۽ ان کي منطقي يا آپريٽر سان گڏ نه . سچائي ٽيبل ۽، اهو پڻ آپريٽر جي ڪم جو نتيجو آهيa & b&&|& منطقي ۽، اهو پڻ هڪ گڏيل آهي، مثال:

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       boolean c = true;
       System.out.println(a & b); // if we multiply true by false, we will definitely get false
       System.out.println(a & c); // true to true will be true
       System.out.println(false & (2 > 5));
 System.out.println((2 < 5) & false);
 // regardless of the truthfulness of the expression in brackets, in which case we have to be content with false
   }
}

پروگرام جا نتيجا:

false
true
false
false

آپريٽر کي &&ڪڏهن ڪڏهن "مختصر ۽" سڏيو ويندو آهي. اهو ساڳيو نتيجو پيدا ڪري ٿو جڏهن آپريٽر جي طور تي منطقي ڪمن سان ڪم ڪندي &. تنهن هوندي به، هن جي ڪم ۾ فرق آهي. تنهن ڪري، توهان اڳ ۾ ئي محسوس ڪيو آهي ته جيڪڏهن a & bاظهار ۾ operand ( ) غلطa آهي ، ته پوء اهو ڪو به احساس ناهي ته آپرينڊ جي قيمت کي جانچڻ لاء : آپريشن جو نتيجو ضرور غلط ٿيندو . تنهن ڪري جيڪڏهن اسان کي بنيادي طور تي ٻئي اوپيرينڊ جي قيمت جي ضرورت ناهي، ان کي استعمال ڪندي اسان پروگرام ۾ حسابن جو تعداد گھٽائي ڇڏيندا آهيون. جيڪڏهن اسان مثال ۾ سڀني آپريٽرن کي مٽائينداسين ، نتيجو بلڪل ساڳيو هوندو، پر پروگرام پاڻ کي ٿورو تيز هلندو (جيتوڻيڪ اسان ان کي نوٽيس نه ڪنداسين، ڇاڪاڻ ته اسان mili-micro بابت ڳالهائي رهيا آهيون ... مختصر ۾. ، وقت جا تمام ننڍا يونٽ). b&&&&&

منطقي يا آپريٽر آهي |، گڏوگڏ مشروط يا آپريٽر آهي ||

جاوا ۾ OR آپريٽر کي علامت سان ظاھر ڪيو ويندو آھي |. هڪ منطقي OR يا disjunction ٻن اظهارن تي لاڳو ٿئي ٿو، ۽ ان جو نتيجو غلط ٿيندو جيڪڏهن ۽ صرف ان صورت ۾ جڏهن ٻئي آپرينڊ غلط آهن. هتي اسان ڪجهه حد تائين ساڳئي تصوير جو مشاهدو ڪيو جيئن آپريٽر جي صورت ۾ &، پر بلڪل ان جي ابتڙ. اهو آهي، جيڪڏهن گهٽ ۾ گهٽ هڪ آپريٽر صحيح آهي ، پوء اظهار جي ضمانت ڏني وئي آهي صحيحa | b هجڻ جي قطع نظر ٻئي آپريٽر جي قيمت جي. جيڪڏهن اهو منطقي ضرب وانگر عمل ڪري ٿو، ته پوءِ OR منطقي اضافو آهي، جيڪڏهن توهان تصور ڪيو ته صحيح آهي 1 ۽ غلط آهي 0. بس ياد رکو ته منطقي اضافو عام اضافو کان مختلف ڪم ڪري ٿو. هن معاملي ۾ 1 + 1 برابر آهي 2 جي نه، پر 1 سان (نمبر 2 صرف هن سسٽم ۾ موجود ناهي). ڪڏهن ڪڏهن disjunction کي 0 ۽ 1 جي وڌ ۾ وڌ سمجھيو ويندو آھي، ۽ ھن صورت ۾، جيڪڏھن گھٽ ۾ گھٽ ھڪڙو operand 1 ( true ) جي برابر آھي، اسان کي بلڪل صحيح ملندو آھي . يا سچي جدول، پڻ سڃاتو وڃي ٿو آپريٽر جو نتيجو : &| منطقي OR، پڻ سڃاتو وڃي ٿو disjunction، مثال:

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       boolean c = true;
       System.out.println(!a | b); // Compose the use of two logical operators: a == true, so !a, as we already know, is false.
       System.out.println(a | c);
       System.out.println((2 < 5) | false); // expression (2 < 5) is true, which means that for any second operand we get a true result
       System.out.println((2 > 5) | true);

   }
}

نتيجو:

false
true
true
true

جيڪڏهن اسان مشروط يا آپريٽر استعمال ڪريون ٿا - ||بجاءِ |، اسان کي بلڪل ساڳيو نتيجو ملندو، پر، جيئن مشروط AND جي صورت ۾ &&، اهو اقتصادي طور تي ڪم ڪندو: جيڪڏهن اسان "اندر" داخل ڪريون ٿا پهرين اوپيرينڊ جي برابر برابر ، جي قدر ٻئي آپريشن جي چڪاس نه ڪئي وئي آهي، پر فوري طور تي نتيجو صحيح آهي .

XOR جاوا - منطقي خاص يا - آپريٽر ^

XOR, modulo 2 اضافو, logical XOR, logical subtraction, strict disjunction, bitwise complement... آپريٽر جا ^ڪيترائي نالا آهن بولن الجبرا ۾. هن آپريٽر کي ٻن آپريشنز تي لاڳو ڪرڻ جو نتيجو صحيح ٿيندو جيڪڏهن آپرينڊ مختلف آهن ۽ غلط آهن جيڪڏهن آپرينڊ ساڳيا آهن. تنهن ڪري، اهو آسان آهي ته ان کي ختم ڪرڻ صفر ( غلط ) ۽ هڪ ( سچو ) سان مقابلو ڪيو وڃي. Truth table XOR، جنهن کي آپريٽر جي نتيجي طور سڃاتو وڃي ٿو ^: مثال:

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       boolean c = true;
       System.out.println(!a ^ b); // Compose the use of two logical operators: a == true, so !a, as we already know, is false.
       System.out.println(a ^ c);
       System.out.println((2 < 5) ^ false);
       System.out.println((2 > 5) ^ true);
   }
}

نتيجو:

false
false
true
true

منطقي عملن جي ترجيح

جيئن رياضي ۾، پروگرامنگ ۾، آپريٽرز کي عمل جو هڪ خاص حڪم هوندو آهي جڏهن اهي ساڳيا اظهار ۾ ظاهر ٿيندا آهن. يونيري آپريٽرز وٽ فائدا آھن بائنري وارن تي، ۽ ضرب (جيتوڻيڪ منطقي) اضافي کان وڌيڪ. اسان منطقي آپريٽرز کي لسٽ ۾ اعليٰ درجو ڏنو آهي، اوترو وڌيڪ سندن ترجيح:

1. !
2. &
3. ^
4. |
5. &&
6. ||

اچو ته مثالن تي نظر رکون. ڪنجونشن ۽ ڊسجنڪشن ( &۽ |) کي مختلف اوليت آهي:

public class Solution {
   public static void main(String[] args) {
       boolean a = true, b = true, c = false;
       System.out.println(a | b & c);
}

جيڪڏهن اسان کي کاٻي کان ساڄي طرف اڳتي وڌڻو هو، يعني، پهرين آپريٽر کي لاڳو ڪرڻ |۽ پوءِ - &، اسان کي قيمت غلط ملندي . پر حقيقت ۾، جيڪڏهن توهان هن پروگرام کي هلائيندا آهيو، توهان کي پڪ ٿي ويندي ته نتيجو صحيح ٿيندو ، ڇاڪاڻ ته منطقي ۽ آپريٽر کي &منطقي يا آپريٽر کان وڌيڪ ترجيح هوندي |. مونجهاري کان بچڻ لاءِ، توهان کي ياد رکڻ جي ضرورت آهي ته ڪهڙو &ڪم ڪندو آهي ضرب جهڙو ۽ |ڪهڙو ڪم ڪندو آهي اضافو. توھان تبديل ڪري سگھوٿا ترجيحي ترتيب. بس بریکٹ استعمال ڪريو، جيئن اسڪول جي رياضي ۾. اچو ته اسان جي مثالي ڪوڊ کي ٿورڙي تبديل ڪريون:

public class Solution {
   public static void main(String[] args) {
       boolean a = true, b = true, c = false;
       System.out.println((a|b)&c);
}

ڇا حال آهي؟ پهرين اسان بریکٹ ۾ منطقي اضافو استعمال ڪندا آهيون، ۽ پوء ضرب. نتيجو ڪوڙو ٿيندو .

پيچيده منطقي اظهار

يقينن، اسان بولن ايڪسپريس ۽ آپريٽرز کي گڏ ڪري سگھون ٿا. اچو ته مضمون جي شروعات کان اظهار کي ياد رکون:

(a | b) | (c < 100) & !(true) ^ (q == 5)

هاڻي اهو ايترو خوفناڪ نظر نٿو اچي. اچو ته هڪ پروگرام لکون جيڪو ان جي قيمت ڏيکاري ٿو، اڳ ۾ ئي a, b, с۽ q. ھڪڙي پيچيده بوليان ايڪسپريس جي قيمت کي ڳڻڻ جو مثال

public class Solution {
   public static void main(String[] args) {
       boolean a = true;
       boolean b = false;
       int c = 25;
       int q = 2;
       System.out.println((a|b) | (c < 100) & !(true)^(q == 5));
   }
}

نوٽ:qاسان جو variable قسم جو آهي int، پر q == 5هي هڪ بولين ايڪسپريشن آهي، ۽ اهو غلط جي برابر آهي ، ڇاڪاڻ ته مٿي اسان qنمبر 2 سان شروع ڪيو آهي. ساڳيو ئي متغير سان آهي c. هي انگ 25 جي برابر آهي، پر (c <100) هڪ بوليان اظهار آهي برابر برابر سچ . هن پروگرام جو نتيجو:

true

ڪمپليڪس Boolean ايڪسپريسشن تمام پيچيده ۽ شاخي حالتن کي جانچڻ لاءِ استعمال ڪري سگھجن ٿا، پر انھن کي وڌيڪ استعمال نه ڪيو وڃي: اھي ڪوڊ کي پڙھڻ ۾ ڏکيائي ڪن ٿا.

Bitwise (bitwise) آپريٽرز

مضمون جي شروعات ۾، اسان ذڪر ڪيو آهي ته آپريٽرز &، |۽ ^جاوا انٽيجر جي قسمن جي سلسلي ۾ استعمال ڪري سگھجن ٿيون. هن معاملي ۾ اهي bitwise آپريٽرز آهن. انهن کي bitwise به سڏيو ويندو آهي، ڇاڪاڻ ته هڪ عدد هڪ بٽ آهي، ۽ اهي عمل خاص طور تي بٽ سان ڪم ڪن ٿا. يقينا، اهي منطقي آپريٽرز جي ڀيٽ ۾ ڪجهه مختلف طريقي سان ڪم ڪن ٿا، ۽ بلڪل ڪيئن سمجهڻ لاء، توهان کي ڄاڻڻ جي ضرورت آهي ته بائنري نمبر سسٽم ڇا آهي. جيڪڏھن توھان ان بابت ڪجھ به نه ڄاڻندا آھيو يا مڪمل طور تي وساري ويٺا آھيو، اسان مشورو ڏيون ٿا ته توھان پھريون مضمون پڙھو Java: bits and bytes ، ۽ ٻين سڀني کي ياد ڏياريو ته بائنري نمبر سسٽم ۾ صرف ٻه عدد آھن - 0 ۽ 1، ۽ سڀ ڊيٽا. ڪمپيوٽر ۾ واضح طور تي پيش ڪيو ويو آهي مشروط صفر ۽ هڪ استعمال ڪندي. انگن مان ڪو به عدد جنهن لاءِ اسان استعمال ڪيون ٿا (ڊيسيمل؛ انهن لاءِ 0 کان 9 تائين 10 مختلف عدد آهن، جن سان اسين ڪو به انگ لکون ٿا) کي بائنري نمبر سسٽم ۾ ڏيکاري سگهجي ٿو. توھان ھڪڙي ڊيسيمل نمبر کي بائنري ۾ تبديل ڪري سگھو ٿا ترتيب وار ڊويزن استعمال ڪندي ھڪڙي ڪالمن ۾ نمبر سسٽم بيس استعمال ڪندي (2). هر قدم تي ڊويزن جا باقي، ريورس آرڊر ۾ لکيل، اسان کي گهربل بائنري نمبر ڏيندو. هتي، مثال طور، ڊيسيمل نمبر 103 کي بائنري نمائندگي ۾ تبديل ڪرڻ آهي: ان کان علاوه &، |۽ ^Java پڻ استعمال ڪري ٿو bitwise آپريٽرز:

• ~ bitwise negation operator
• >>ساڄي طرف شفٽ
• >>>غير دستخط ٿيل ساڄي طرف شفٽ
• <<ساڄي طرف کاٻي طرف شفٽ

شروعات ڪندڙن لاءِ، bitwise آپريٽرس ڏاڍا مبهم ۽ مصنوعي لڳي رهيا آهن. اهي اڪثر ڪري نٿا سمجهن ته انهن کي ڪهڙي ضرورت آهي، سواءِ تعليمي مسئلن کي حل ڪرڻ جي. حقيقت ۾، اھي گھٽ ۾ گھٽ استعمال ڪري سگھجن ٿيون موثر ڊويزن ۽ ضرب کي منظم ڪرڻ لاءِ، ۽ پروفيشنل انھن کي استعمال ڪن ٿا انڪوڊنگ/ڊيڪوڊنگ، انڪرپشن، ۽ بي ترتيب نمبرن جي پيدا ڪرڻ لاءِ.

Bitwise آپريٽرز ۽، | ۽ ^

اچو ته هڪ مثال ڏسو ته اهي آپريٽرز ڪيئن ڪم ڪن ٿا. اچو ته چئون ته اسان وٽ ٻه عدد آهن:

int a = 25;
int b = 112; 

اسان کي انهن تي ٽي عمل لاڳو ڪرڻ جي ضرورت آهي &، |۽ ^اسڪرين تي نتيجو ڏيکاري ٿو. هتي پروگرام جو ڪوڊ آهي:

public class Solution {
   public static void main(String[] args) {

       int a = 25;
       int b = 112;

       int res1 = a & b;
       int res2 = a | b;
       int res3 = a ^ b;

       System.out.println("a & b = " + res1);
       System.out.println("a | b = " + res2);
       System.out.println("a ^ b = " + res3);

   }
}

پروگرام جو نتيجو هن ريت آهي:

a & b = 16
a | b = 121
a ^ b = 105

جيڪڏهن توهان نٿا سمجهو ته ڇا ٿي رهيو آهي، نتيجو تمام گهڻو، تمام پراسرار نظر اچي ٿو. حقيقت ۾، هر شيء ان کان وڌيڪ آسان آهي. Bitwise آپريٽرز "ڏسو" آپرينڊ نمبرن کي پنھنجي بائنري شڪل ۾. ۽ پوءِ اهي لاڳو ٿين ٿا منطقي آپريٽرز &، |يا ^ٻنهي نمبرن جي لاڳاپيل انگن (بٽ) تي. تنهن ڪري، &نمبر 25 جي بائنري نمائندگي جي آخري بٽ لاءِ منطقي طور تي نمبر 112 جي بائنري نمائندگي جي آخري بٽ تائين شامل ڪري ٿو، آخري بٽ سان گڏ پين الٽيميٽ بٽ، ۽ ائين: ساڳي منطق ۾ ڳولي سگھجي ٿو. جي صورت |۽ ^.

ساڄي يا کاٻي پاسي ڦيرائڻ

جاوا ۾ ڪيترائي بٽ شفٽ آپريٽر آھن. سڀ کان عام طور تي استعمال ٿيل آپريٽرز <<آهن ۽ >>. اهي هڪ عدد جي بائنري نمائندگي کي ترتيب سان کاٻي يا ساڄي ڏانهن منتقل ڪن ٿا، ۽ ساڄي طرف شفٽ جي صورت ۾، نشاني کي محفوظ رکڻ دوران (اسان وضاحت ڪنداسين ته نشاني کي محفوظ ڪرڻ جو مطلب ڇا آهي). ٻيو حق شفٽ آپريٽر آهي >>>. اهو ساڳيو ڪم ڪري ٿو پر >>نشاني کي محفوظ نٿو ڪري. تنهن ڪري، اچو ته هڪ مثال استعمال ڪندي انهن جي ڪم کي ڏسو. int a = 13 a << 1نمبر a جي بائنري نمائندگي جي سڀني بٽس کي کاٻي طرف 1 بٽ منتقل ڪري ٿو. آسان ڪرڻ لاءِ، اچو ته نمبر 13 کي بائنري شڪل ۾ 0000 1101 طور پيش ڪريون. حقيقت ۾، ھي نمبر ھن طرح نظر اچي ٿو: 00000000 00000000 00000000 00001101، جتان جاوا intنمبرن لاءِ 4 بائيٽ يا 32 بٽ مختص ڪري ٿو. بهرحال، اهو مثال ۾ ڪو ڪردار ادا نٿو ڪري، تنهنڪري هن مثال ۾ اسان پنهنجي نمبر کي هڪ بائيٽ تي غور ڪنداسين. ساڄي پاسي خالي ٿيل سا صفر سان ڀريل آهي. هن عمل جي نتيجي ۾، اسان کي نمبر 26 ملي ٿو. a << 2اهو نمبر جي بائنري نمائندگي جي سڀني بٽس کي a2 بٽ جي کاٻي طرف شفٽ ڪري ٿو، ۽ ساڄي پاسي خالي ٿيل ٻه بٽ صفر سان ڀرجي ويا آهن. نتيجي طور، اسان کي نمبر 52 ملندو. a << 3نتيجو ٿيندو 104... نموني کي نوٽ ڪريو؟ an پوزيشن کان کاٻي طرف ڦيرائڻ ائين ڪم ڪندو آهي جيئن هڪ عدد کي a2 سان ضرب ڪرڻ n جي طاقت سان. ساڳيو ئي منفي نمبرن تي لاڳو ٿئي ٿو. اهو -13 << 3نتيجو ڏيندو -104. a >> nهڪ عدد n پوزيشن جي بائنري نمائندگي کي ساڄي طرف شفٽ ڪري ٿو. مثال طور، 13 >> 1 نمبر 1101 کي نمبر 0110 ۾ تبديل ڪري ٿو، يعني 6. ۽ 13 >> 2نتيجو 3 ٿيندو. اھو آھي، بنيادي طور تي، ھتي اسان نمبر کي 2 سان n جي طاقت سان ورهائيندا آھيون، جتي n شفٽ جو تعداد آھي. ساڄي طرف، پر هڪ احتياط سان: جيڪڏهن انگ بي جوڙ آهي، ته هن آپريشن دوران اسان انگ جي آخري بٽ کي ري سيٽ ڪرڻ لڳيون ٿا. پر منفيات سان صورتحال ڪجهه مختلف آهي. اچو ته چئو، چيڪ ڪرڻ جي ڪوشش ڪريو ته پروگرام ڇا پيدا ڪندو جيڪڏهن توهان ان کي آپريشن ڪرڻ لاء چيو -13 >> 1. توهان ڏسندا نمبر -7، نه -6، جيئن توهان سوچيو. اهو ان ڪري ٿئي ٿو جو طريقي سان منفي نمبر جاوا ۽ ٻين پروگرامنگ ٻولين ۾ محفوظ ٿيل آهن. اهي ذخيرو ٿيل آهن جنهن کي سڏيو ويندو آهي مڪمل ڪوڊ. هن معاملي ۾، سڀ کان اهم انگ (هڪ کاٻي پاسي) نشاني کي ڏنو ويو آهي. هڪ منفي نمبر جي صورت ۾، سڀ کان اهم انگ اکر 1 آهي.

اضافي ڪوڊ

اچو ته نمبر تي غور ڪريو int a = 13. جيڪڏهن پروگرام ۾ توهان ڪمانڊ استعمال ڪندي ان جي بائنري نمائندگي ڪنسول تي پرنٽ ڪندا System.out.println(Integer.toBinaryString(a));ته پوءِ اسان کي 1101 ملندو. حقيقت ۾، هي هڪ شارٽ هينڊ نوٽيشن آهي، ڇاڪاڻ ته ٽائپ نمبر intميموري ۾ 4 بائيٽ وٺندو آهي، تنهنڪري ڪمپيوٽر ان کي وڌيڪ ”ڏسندو“ آهي. هن وانگر:

00000000 00000000 00000000 00001101

سڀ کان اهم عدد صفر آهي، جنهن جو مطلب آهي ته اسان وٽ هڪ مثبت نمبر آهي. اضافي ڪوڊ ۾ تبديل ڪرڻ لاء:

1. اسان کي نام نهاد "سڌي ڪوڊ" ۾ نمبر -13 لکندا آهيون. هن کي ڪرڻ لاء، نمبر جي سڀ کان اهم عدد کي 1 ۾ تبديل ڪريو.
   عمل جو نتيجو:

   
   10000000 0000000 0000000 00001101

2. اڳيون، اسان سڀني بٽن کي ڦيرايو (اسان 0 کان 1، ۽ 1 کان 0 تبديل ڪريون ٿا) سواء سائن بٽ جي. حقيقت ۾، اسان اڳ ۾ ئي ان کي تبديل ڪيو آهي.
   عمل جا نتيجا:

   
   11111111 11111111 11111111 11110010

   (ها، مرحلا 1 ۽ 2 گڏيل ٿي سگهي ٿو، پر اهو بهتر آهي ته انهي طريقي سان سوچڻ)

3. 1 شامل ڪريو نتيجو نمبر تي.
   عمل جو نتيجو:

   
   11111111 11111111 11111111 11110011

نتيجو بائنري نمبر -13 آهي، ٻن جي مڪمل ڪوڊ ۾ لکيل آهي، ۽ بٽ شفٽ (۽ ٻيا عمل) خاص طور تي ان تي لاڳو ڪيو ويندو. اهو صرف اهو آهي ته آپريشن جي منطق ۾ فرق سڀني عملن ۾ قابل ذڪر نه آهي. اچو ته چئو، ساڳي کاٻي طرف شفٽ ڪرڻ لاءِ، فرق ناقابلِ ادراڪ آهي؛ اسان منفي انگن سان ساڳيءَ طرح ڪم ڪري سگهون ٿا جيئن مثبت انگن سان. هاڻي اچو ته ساڄي طرف ڦيرايو -13 >> 1. جيئن ته اسان جو آپريٽر >>نشاني کي محفوظ ڪري ٿو، هن آپريشن ۾ کاٻي پاسي کان آزاد ٿيل سڀئي بٽ صفر سان نه، پر انهن سان ڀريل آهن. اهڙيء طرح، نمبر ڦيرائڻ

11111111 11111111 11111111 11110011

ساڄي پاسي هڪ سا، جنهن جي نتيجي ۾ بِٽن جو هيٺيون سلسلو:

11111111 11111111 11111111 11111001

جيڪڏهن اسان هن نمبر کي سڌو ڪوڊ ۾ تبديل ڪريون ٿا (يعني، پهرين 1 کي گهٽايو، پوء پهرين کان سواء سڀني بٽس کي ڦيرايو) اسان کي نمبر ملندو:

10000000 00000000 00000000 00000111

يا -7. ھاڻي ته اسان سمجھي چڪا آھيون سائن محفوظ ڪرڻ واري ساڄي شفٽ آپريٽر، اھو واضح ٿي ويندو ته اھو آپريٽر کان ڪيئن مختلف آھي >>>. a >>> n- هي عمل هڪ غير دستخط ٿيل شفٽ آهي، يعني، اهو هڪ نمبر جي بائنري نمائندگي کي aساڄي طرف n بٽس ذريعي شفٽ ڪري ٿو، پر کاٻي پاسي کان خالي ٿيل n بٽس کي ڀريندو آهي نه، جهڙوڪ آپريٽر >>، پر صفر سان. اچو ته آپريشن ڪريون -13 >>> 1. اسان وٽ اڳ ۾ ئي نمبر -13ٻن جي مڪمل ۾ آهي:

11111111 11111111 11111111 11110011

ساڄي طرف 1 بٽ منتقل ڪرڻ ۽ مفت بٽ کي صفر سان ڀرڻ سان، اسان ھيٺ ڏنل نمبر حاصل ڪندا آھيون:

01111111 11111111 11111111 11111001

ڇا ڏئي ٿو انگ اکر ۾ decimal notation 2147483641.

Bitwise negation operator ~

هي يونيري آپريٽر بلڪل آسانيءَ سان ڪم ڪري ٿو: اهو هڪ عدد جي بائنري نمائندگي جي هر بٽ کي ريورس ڪري ٿو. اچو ته نمبر وٺون -13:

11111111 11111111 11111111 11110011

bitwise negation آپريشن ~13صرف هر بٽ جي قيمت کي ريورس ڪندو. نتيجي طور، اسان حاصل ڪريون ٿا:

00000000 00000000 00000000 00001100

يا 12decimal شڪل ۾.

مختصر نتيجا

• سڀئي منطقي آپريٽرس Boolean ايڪسپريشنز تي لاڳو ٿين ٿا، يعني اھي آھن جن کي سچ يا غلط چئي سگھجي ٿو .
• جيڪڏهن آپريٽر &، |يا ^انگن تي لاڳو ڪيا ويا آهن، اسان هاڻي منطقي عملن بابت نه، پر bitwise وارن بابت ڳالهائي رهيا آهيون. يعني ٻنهي انگن کي بائنري سسٽم ۾ تبديل ڪيو وڃي ٿو ۽ منطقي اضافو، ضرب يا ذخيري جا عمل انهن نمبرن تي ٿوري دير سان لاڳو ٿين ٿا.
• رياضياتي منطق ۾، آپريٽرز &۽ |ملندڙ جلندڙ ۽ تفاوت.
• منطقي ۽ 1 ( سچو ) ۽ 0 ( غلط ) کي ضرب ڪرڻ جي برابر آهي.
• منطقي يا 1 ( سچو ) ۽ 0 ( غلط ) جي وچ ۾ وڌ ۾ وڌ ڳولڻ جي برابر آهي .
• انٽيجر الف جي bitwise نفي لاءِ، آپريٽر استعمال ڪيو ويندو آھي ~a.
• Boolean ايڪسپريس a کي منطقي طور تي رد ڪرڻ لاءِ، استعمال ڪريو آپريٽر !a.
• ناڪاري انگن کي ذخيرو ۽ پروسيس ڪيو ويو آهي ٻن جي مڪمل ڪوڊ ۾.
• ساڄي طرف ساڄي طرف ڦيرائڻ سان >>نشاني ( >>>) محفوظ ٿي سگھي ٿي يا نه.