جاوا میں منطقی آپریٹرز

• جاوا میں منطقی آپریٹرز
• منطقی نفی آپریٹر !
• منطقی AND - &، نیز مشروط AND - &&
• منطقی OR آپریٹر ہے |، نیز مشروط OR آپریٹر ہے ||
• XOR - منطقی خصوصی یا - آپریٹر ^
• منطقی کارروائیوں کی ترجیح
• پیچیدہ منطقی تاثرات
• Bitwise (bitwise) آپریٹرز
• بٹ وائز آپریٹرز اور، | اور ^
• اضافی کوڈ
• Bitwise نفی آپریٹر ~

جاوا میں منطقی آپریشنز

منطقی کارروائیاں بولین آپریٹرز کا استعمال کرتے ہوئے کی جاتی ہیں۔ طاغوت کو معاف کر دیں، لیکن حالات ایسے ہی ہیں۔ بنیادی منطقی کارروائیوں (پروگرامنگ اور ریاضی میں) کو منطقی دلائل (آپرینڈز) پر لاگو کیا جا سکتا ہے، اور اعداد پر ریاضی کی کارروائیوں کی طرح مزید پیچیدہ تاثرات بنانے کے لیے بھی استعمال کیا جا سکتا ہے۔ مثال کے طور پر اظہار:

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

چار آپرینڈز کے ساتھ ایک پیچیدہ منطقی اظہار ہے: (a | b), کہاں аاور bٹائپ متغیرات ہیں boolean (c < 100) (true) (q == 5) ۔ بدلے میں، ایک سادہ منطقی اظہار (a | b)بھی دو اوپرینڈ دلائل پر مشتمل ہوتا ہے۔ ایک منطقی آپرینڈ ایک اظہار ہے جسے سچ یا غلط، سچ یا غلط کہا جاسکتا ہے ۔ booleanجاوا کی زبان میں، بولین آپرینڈ ٹائپ یا بولین کا اظہار ہے ، مثال کے طور پر:

• (2 < 1)- منطقی کام، اس کی قدر غلط ہے۔
• true- ایک منطقی عمل جس کی قدر واضح طور پر درست ہے۔
• boolean a--.لوجیکل آپرینڈ بھی ہو سکتا ہے، جیسے بولین a
• int a = 2- ایک منطقی آپرینڈ نہیں ہے ، یہ صرف قسم کا ایک متغیر ہے۔int
• String a = "true"یہ بھی ایک منطقی کام نہیں ہے ۔ یہ ایک سٹرنگ ہے جس کی ٹیکسٹ ویلیو ہے "true"۔

جاوا میں درج ذیل منطقی آپریشنز دستیاب ہیں:

• منطقی نفی ، NOTجسے الٹا بھی کہا جاتا ہے۔ جاوا میں، یہ !آپرینڈ سے پہلے "" علامت سے ظاہر ہوتا ہے۔ ایک آپرینڈ پر لاگو ہوتا ہے۔
• منطقی اور ، یہ ANDایک کنکشن بھی ہے۔ &دو آپرینڈز کے درمیان ایک " " علامت کے ذریعہ اشارہ کیا جاتا ہے جس پر یہ لاگو ہوتا ہے۔
• منطقی یا Java میں ، یہ بھی ہے - OR، یہ بھی disjunction ہے۔ |جاوا میں، یہ دو آپرینڈز کے درمیان علامت "" سے ظاہر ہوتا ہے ۔
• خصوصی یا , XORسخت اختلاف۔ ^جاوا میں، یہ دو آپرینڈز کے درمیان علامت "" سے ظاہر ہوتا ہے ۔
• جاوا میں، منطقی آپریٹرز میں مشروط یا ، کے طور پر اشارہ کیا جاتا ہے ||، نیز مشروط اور - &&۔

نوٹ: ریاضی کی منطق میں بھی وہ مساوات کے تعلق کو، دوسرے لفظوں میں، مساوات پر غور کرتے ہیں۔ تاہم، جاوا میں، مساوات آپریٹر کو==منطقی آپریٹر نہیں سمجھا جاتا ہے۔ توجہ! جاوا میں، منطقی آپریٹرز&،|اور^انٹیجرز پر بھی لاگو ہوتے ہیں۔ اس صورت میں، وہ قدرے مختلف طریقے سے کام کرتے ہیں اور انہیں bitwise (یا bitwise) منطقی آپریٹرز کہا جاتا ہے۔ ان کے بارے میں - مضمون کے آخر میں. آئیے جاوا منطقی آپریٹرز میں سے ہر ایک کی مختصر وضاحت کے ساتھ ایک جدول دیکھیں، اور ذیل میں ہم ان کو مزید تفصیل سے بیان کریں گے اور کوڈ کی مثالیں فراہم کریں گے۔

منطقی نفی آپریٹر !

یہ آپریٹر unary ہے، یعنی یہ ایک ہی بولین ایکسپریشن یا اوپرینڈ پر لاگو ہوتا ہے۔ یہ سمجھنا بہت آسان ہے، کسی بھی نفی کی طرح: آپریٹر محض اظہار کے معنی کو اس کے مخالف میں بدل دیتا ہے۔ سچائی کی میز یا نفی آپریشن کرنے کے نتائج: مثال. منطقی نفی آپریشن

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 - &&

منطقی AND یا conjunction کا اطلاق دو اظہاروں پر ہوتا ہے، اور اس کا نتیجہ صرف اسی صورت میں درست ہوگا جب دونوں آپرینڈ صحیح ہوں۔ یعنی، اگر aیا آپرینڈز میں سے ایک غلطb ہے ، تو اظہار غلط ہو جائے گا قطع نظر دوسرے آپریٹر کی قدر کے۔ اگر آپ تصور کرتے ہیں کہ صحیح نمبر 1 ہے اور غلط 0 ہے، تو آپریٹر بالکل عام ضرب کی طرح کام کرتا ہے۔ لہذا، منطقی AND کو اکثر "منطقی ضرب" کہا جاتا ہے۔ اور، ویسے، یہ حقیقت آپریٹر کے آپریشن کو تیزی سے یاد رکھنے اور اسے منطقی یا آپریٹر کے ساتھ الجھانے میں مدد دیتی ہے ۔ سچائی کی میز اور، یہ بھی آپریٹر کے کام کا نتیجہ ہے۔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اظہار ( ) میں آپرینڈ غلطa ہے ، تو آپرینڈ کی قدر کو چیک کرنے کا کوئی مطلب نہیں ہے : آپریشن کا نتیجہ یقینی طور پر غلط ہوگا ۔ لہذا اگر ہمیں بنیادی طور پر دوسرے آپرینڈ کی قدر کی ضرورت نہیں ہے، تو اس کا استعمال کرتے ہوئے ہم پروگرام میں حسابات کی تعداد کو کم کر دیتے ہیں۔ اگر ہم مثال میں تمام آپریٹرز کو اس کے ساتھ بدل دیں تو نتیجہ بالکل ایک جیسا ہو گا، لیکن پروگرام خود تھوڑا تیز چلے گا (حالانکہ ہم اس پر توجہ نہیں دیں گے، کیونکہ ہم mili-micro... مختصراً بات کر رہے ہیں ، وقت کی بہت چھوٹی اکائیاں)۔ b&&&&&

منطقی OR آپریٹر ہے |، نیز مشروط OR آپریٹر ہے ||

جاوا میں OR آپریٹر کو علامت سے ظاہر کیا جاتا ہے |۔ ایک منطقی OR یا disjunction دو اظہارات پر لاگو ہوتا ہے، اور اس کا نتیجہ غلط ہوگا اگر اور صرف اس صورت میں جب دونوں آپرینڈ غلط ہوں۔ یہاں ہم کسی حد تک وہی تصویر دیکھتے ہیں جو آپریٹر کے معاملے میں ہے &، لیکن بالکل اس کے برعکس۔ یعنی، اگر کم از کم ایک آپرینڈ سچ ہے، تو دوسرے آپریٹر کی قدر سے قطع نظر اظہار کے درستa | b ہونے کی ضمانت دی جاتی ہے ۔ اگر یہ منطقی ضرب کی طرح برتاؤ کرتا ہے، تو OR منطقی اضافہ ہے، اگر آپ تصور کرتے ہیں کہ سچ ہے 1 اور غلط ہے 0۔ بس یاد رکھیں کہ منطقی اضافہ عام اضافے سے مختلف طریقے سے کام کرتا ہے۔ اس معاملے میں 1 + 1 2 کے نہیں بلکہ 1 کے برابر ہے (نمبر 2 اس سسٹم میں موجود نہیں ہے)۔ کبھی کبھی ڈسکشن کو زیادہ سے زیادہ 0 اور 1 کے طور پر سمجھا جاتا ہے، اور اس صورت میں، اگر کم از کم ایک آپرینڈ 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

اگر ہم مشروط OR آپریٹر کا استعمال کرتے ہیں - ||اس کے بجائے |، ہمیں بالکل وہی نتیجہ ملے گا، لیکن، جیسا کہ مشروط AND کے معاملے میں ، یہ اقتصادی طور پر کام کرے گا: اگر ہم سچ&& کے برابر پہلے آپرینڈ کو "اندر" کرتے ہیں تو ، کی قدر دوسرا آپرینڈ چیک نہیں کیا جاتا ہے، لیکن فوری طور پر نتیجہ سچ ہے .

XOR Java - منطقی خصوصی یا - آپریٹر ^

XOR, modulo 2 اضافہ، منطقی XOR، منطقی گھٹاؤ، سخت تفاوت، bitwise complement... آپریٹر کے ^بولین الجبرا میں بہت سے نام ہیں۔ اس آپریٹر کو دو آپرینڈز پر لاگو کرنے کا نتیجہ درست ہوگا اگر آپرینڈز مختلف ہوں گے اور غلط ہوں گے اگر آپرینڈز ایک ہیں۔ لہذا، اس کا موازنہ صفر ( غلط ) اور والے ( سچ ) کے ساتھ کرنا آسان ہے۔ ٹروتھ ٹیبل 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);
}

اگر ہم بائیں سے دائیں آگے بڑھیں، یعنی پہلے آپریٹر کو لاگو کریں |اور پھر - ، تو ہمیں غلط& ویلیو ملے گی ۔ لیکن درحقیقت، اگر آپ اس پروگرام کو چلاتے ہیں، تو آپ کو یقین ہو جائے گا کہ آؤٹ پٹ صحیح ہو گا ، کیونکہ logical AND آپریٹر کو logical OR آپریٹر سے زیادہ ترجیح حاصل ہوگی ۔ الجھن سے بچنے کے لیے، آپ کو یہ یاد رکھنے کی ضرورت ہے کہ کیا چیز ضرب کی طرح برتاؤ کرتی ہے اور کیا اضافے کی طرح برتاؤ کرتی ہے۔ آپ ترجیحی ترتیب کو تبدیل کر سکتے ہیں۔ اسکول کی ریاضی کی طرح صرف بریکٹ استعمال کریں۔ آئیے اپنے مثال کے کوڈ کو تھوڑا سا تبدیل کریں: &|&|

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ہمارا متغیر قسم کا ہے int، لیکن q == 5یہ ایک بولین اظہار ہے، اور یہ غلط کے برابر ہے ، کیونکہ اوپر ہم نے qنمبر 2 سے شروع کیا ہے۔ متغیر کے ساتھ بھی یہی ہے c۔ یہ نمبر 25 کے برابر ہے، لیکن (c <100) سچ کے برابر بولین اظہار ہے ۔ اس پروگرام کا نتیجہ:

true

پیچیدہ بولین ایکسپریشنز کا استعمال بہت پیچیدہ اور شاخ دار حالات کو جانچنے کے لیے کیا جا سکتا ہے، لیکن ان کا زیادہ استعمال نہیں کیا جانا چاہیے: وہ کوڈ کو پڑھنا مشکل بنا دیتے ہیں۔

Bitwise (bitwise) آپریٹرز

مضمون کے آغاز میں، ہم نے ذکر کیا کہ آپریٹرز &، |اور ^جاوا انٹیجر کی اقسام کے سلسلے میں استعمال کیا جا سکتا ہے۔ اس معاملے میں وہ بٹ وائز آپریٹرز ہیں۔ انہیں بٹ وائز بھی کہا جاتا ہے، کیونکہ ایک ہندسہ ایک بٹ ہوتا ہے، اور یہ آپریشن خاص طور پر بٹس کے ساتھ کام کرتے ہیں۔ بلاشبہ، وہ منطقی آپریٹرز سے کچھ مختلف طریقے سے کام کرتے ہیں، اور یہ سمجھنے کے لیے کہ کس طرح، آپ کو یہ جاننا ہوگا کہ بائنری نمبر سسٹم کیا ہے۔ اگر آپ اس کے بارے میں کچھ نہیں جانتے یا مکمل طور پر بھول گئے ہیں، تو ہمارا مشورہ ہے کہ آپ پہلے مضمون جاوا: بٹس اور بائٹس پڑھیں ، اور باقی سب کو یاد دلائیں کہ بائنری نمبر سسٹم میں صرف دو ہندسے ہوتے ہیں - 0 اور 1، اور تمام ڈیٹا۔ کمپیوٹر میں مشروط صفر اور والے کا استعمال کرتے ہوئے واضح طور پر نمائندگی کی جاتی ہے۔ ہم جن نمبروں کے عادی ہیں ان میں سے کوئی بھی (اعشاریہ؛ ان کے لیے 0 سے 9 تک 10 مختلف ہندسے ہیں، جن سے ہم کوئی بھی نمبر لکھتے ہیں) کو بائنری نمبر سسٹم میں دکھایا جا سکتا ہے۔ آپ نمبر سسٹم بیس (2) کا استعمال کرتے ہوئے ترتیب وار تقسیم کا استعمال کرتے ہوئے اعشاریہ نمبر کو بائنری میں تبدیل کر سکتے ہیں۔ ہر قدم پر تقسیم کے باقیات، الٹے ترتیب میں لکھے گئے، ہمیں مطلوبہ بائنری نمبر دیں گے۔ یہاں، مثال کے طور پر، اعشاریہ نمبر 103 کو بائنری نمائندگی میں تبدیل کرنا ہے: اس کے علاوہ &، |اور ^Java بھی bitwise آپریٹرز استعمال کرتا ہے:

• ~ بٹ وائز نفی آپریٹر
• >>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

اگر آپ نہیں سمجھتے کہ کیا ہو رہا ہے، تو نتیجہ بہت، بہت پراسرار لگتا ہے۔ درحقیقت، سب کچھ اس سے کہیں زیادہ آسان ہے۔ بٹ وائز آپریٹرز آپرینڈ نمبرز کو اپنی بائنری شکل میں "دیکھتے ہیں"۔ اور پھر وہ منطقی آپریٹرز &، |یا ^دونوں نمبروں کے متعلقہ ہندسوں (بٹس) پر لاگو کرتے ہیں۔ لہٰذا، &نمبر 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 ہوگا... پیٹرن پر غور کریں؟ n پوزیشنز کے ذریعے بائیں طرف Bitwise شفٹ کرنا aایسے کام کرتا ہے جیسے کسی نمبر کو an کی طاقت سے 2 سے ضرب دینا۔ منفی نمبروں پر بھی یہی لاگو ہوتا ہے۔ یہ -13 << 3نتیجہ -104 دے گا۔ a >> nنمبر n پوزیشنز کی بائنری نمائندگی کو دائیں طرف منتقل کرتا ہے۔ مثال کے طور پر، 13 >> 1 نمبر 1101 کو نمبر 0110 میں تبدیل کرتا ہے، یعنی 6۔ اور 13 >> 2نتیجہ 3 ہو گا۔ یعنی جوہر میں، یہاں ہم نمبر کو 2 سے n کی طاقت سے تقسیم کرتے ہیں، جہاں n شفٹوں کی تعداد ہے۔ دائیں طرف، لیکن ایک انتباہ کے ساتھ: اگر نمبر odd ہے، تو اس آپریشن کے دوران ہم نمبر کے آخری بٹ کو دوبارہ ترتیب دیتے نظر آتے ہیں۔ لیکن منفی کے ساتھ صورت حال کچھ مختلف ہے. چلیں، یہ چیک کرنے کی کوشش کریں کہ اگر آپ اسے آپریشن کرنے کو کہتے ہیں تو پروگرام کیا پیدا کرے گا -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- یہ آپریشن ایک غیر دستخط شدہ شفٹ ہے، یعنی، یہ نمبر کی بائنری نمائندگی کو an بٹس کے ذریعے دائیں طرف منتقل کرتا ہے، لیکن بائیں جانب خالی ہونے والے n بٹس کو آپریٹر کی طرح نہیں >>بلکہ زیرو سے بھرتا ہے۔ چلو آپریشن کرتے ہیں -13 >>> 1۔ -13ہمارے پاس پہلے سے ہی دو کی تکمیل میں نمبر ہے :

11111111 11111111 11111111 11110011

1 بٹ کو دائیں طرف منتقل کرنے اور مفت بٹ کو صفر سے بھرنے سے، ہمیں درج ذیل نمبر ملتا ہے:

01111111 11111111 11111111 11111001

اعشاریہ اشارے میں نمبر کیا دیتا ہے 2147483641۔

Bitwise نفی آپریٹر ~

یہ یونری آپریٹر بہت آسانی سے کام کرتا ہے: یہ ایک عدد کی بائنری نمائندگی کے ہر بٹ کو الٹ دیتا ہے۔ آئیے نمبر لیتے ہیں -13:

11111111 11111111 11111111 11110011

bitwise negation آپریشن ~13ہر بٹ کی قدر کو آسانی سے ریورس کر دے گا۔ نتیجے کے طور پر ہم حاصل کرتے ہیں:

00000000 00000000 00000000 00001100

یا 12اعشاریہ شکل میں۔

مختصر نتائج

• تمام منطقی آپریٹرز بولین ایکسپریشنز پر لاگو ہوتے ہیں، یعنی وہ جن کو سچ یا غلط کہا جا سکتا ہے ۔
• اگر آپریٹرز &، |یا ^نمبرز پر لاگو ہوتے ہیں، تو ہم اب منطقی کارروائیوں کے بارے میں بات نہیں کر رہے ہیں، بلکہ بٹ وائز کے بارے میں بات کر رہے ہیں۔ یعنی دونوں نمبرز کو بائنری سسٹم میں تبدیل کر دیا جاتا ہے اور ان نمبروں پر منطقی اضافے، ضرب یا گھٹاؤ کے عمل کو تھوڑا تھوڑا کیا جاتا ہے۔
• ریاضیاتی منطق میں، آپریٹرز &اور |conjunction اور disjunction سے مطابقت رکھتے ہیں۔
• منطقی اور 1 ( سچ ) اور 0 ( غلط ) کو ضرب دینے کے مترادف ہے ۔
• منطقی OR 1 ( سچ ) اور 0 ( غلط ) کے درمیان زیادہ سے زیادہ تلاش کرنے کے مترادف ہے ۔
• انٹیجر a کی بٹ وار نفی کے لیے، آپریٹر استعمال کیا جاتا ہے ~a۔
• منطقی طور پر بولین اظہار کی نفی کرنے کے لیے، آپریٹر کا استعمال کریں !a۔
• منفی نمبروں کو دو کے تکمیلی کوڈ میں محفوظ اور پروسیس کیا جاتا ہے۔
• دائیں طرف تھوڑا سا شفٹ >>نشان ( >>>) کو محفوظ رکھ سکتا ہے یا نہیں۔