جاوا آپریٹرز کا تعارف: منطقی، ریاضی، بٹ وار

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

• جاوا میں آپریٹرز کی اقسام کیا ہیں؟
• JavaRush کورس میں جاوا آپریٹرز
• جاوا میں نمبر آپریشنز
• جاوا میں منطقی آپریشنز
• جاوا میں بٹ وائز آپریشنز
• جاوا میں آپریشنز کی ترجیح
• استعمال کی مفید مثالیں۔

جاوا میں آپریٹرز کی اقسام کیا ہیں؟

کسی بھی آپریشن کے لیے ہمیں کم از کم دو چیزوں کی ضرورت ہے:

• آپریٹر
• کام

آپریٹر کی مثال دو نمبروں کو جوڑنے کے عمل میں ایک سادہ پلس ہوگی۔ اور اس معاملے میں ایک دوسرے میں شامل کردہ نمبر آپرینڈز ہوں گے۔ لہذا، آپریٹرز کی مدد سے، ہم ایک یا زیادہ آپرینڈز پر آپریشن کرتے ہیں۔ آپریٹرز جو دو آپرینڈز پر آپریشن کرتے ہیں انہیں بائنری کہا جاتا ہے۔ مثال کے طور پر، دو نمبر شامل کرنا۔ آپریٹرز جو ایک ہی آپرینڈ پر آپریشن کرتے ہیں انہیں یونری کہا جاتا ہے۔ مثال کے طور پر، ایک unary مائنس.

JavaRush کورس میں جاوا آپریٹرز

پہلی جستجو - جاوا سنٹیکس کے چوتھے درجے پر کئی لیکچر جاوا آپریٹرز کے لیے وقف ہیں ۔ خاص طور پر، مشروط آپریٹرز جیسے کہ بولین ۔ کورس میں 22 کام ہیں جو آپ کو موازنہ آپریٹرز، مشروط آپریٹرز، اور منطقی آپریٹرز کے کام کو سمجھنے میں مدد کریں گے۔

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

سب سے عام آپریشن جو پروگرامر نمبروں پر انجام دیتے ہیں وہ متغیر کو عددی قدر تفویض کرنا ہے۔ وہ، آپریٹر کی طرح، =آپ سے واقف ہے:

int a = 1;
int b = 2;
int c = 3;

ریاضی کے عمل بھی ہیں۔ وہ بائنری ریاضی کے آپریٹرز کا استعمال کرتے ہوئے کئے جاتے ہیں: جدول 1. بائنری ریاضی کے آپریٹرز پہلے چار آپریٹرز کو کوئی سوال نہیں اٹھانا چاہیے: سب کچھ ویسا ہی ہے جیسا کہ ریاضی میں ہے۔ آخری آپریٹر، بقیہ ڈویژن، بھی کچھ زیادہ پیچیدہ نہیں کرتا ہے۔ مثال کے طور پر، اگر ہم 24 کو 7 سے تقسیم کرتے ہیں، تو ہمیں 3 پورے نمبر اور 3 باقی ملتے ہیں۔ یہ باقی ہے کہ یہ آپریٹر واپس آئے گا:

System.out.println(24 % 7); // prints 3

یہاں سرکاری اوریکل دستاویزات کی سائٹ سے مثالیں ہیں: یہ پروگرام درج ذیل کو آؤٹ پٹ کرے گا: 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3 جاوا آپ کو اجازت دیتا ہے۔ یکجا کرنا: مثال کے طور پر، آپریٹرز اسائنمنٹس اور ریاضی کے آپریٹرز۔ آئیے ایک مثال دیکھتے ہیں:

int x = 0;
x = x + 1; // x = 0 + 1 => x = 1
x = x + 1; // x = 1 + 1 => x = 2
x = x + 1; // x = 2 + 1 => x = 3

یہاں ہم نے ایک متغیر کی تعریف کی ہے xاور اسے صفر کی قدر تفویض کی ہے۔ اگلا، ہر لائن میں ہم xمتغیر کی موجودہ قدر کے مجموعے کے لیے ایک قدر تفویض کرتے ہیں xاور ایک۔ ہر سطر کے تبصروں میں وضاحتیں موجود ہیں۔ اس طریقہ کار کو متغیر کو بڑھانا یا بڑھانا کہا جاتا ہے۔ اوپر دی گئی مثال سے بڑھتے ہوئے آپریشن کو آپریٹرز کے امتزاج کا استعمال کرتے ہوئے اسی طرح کے آپریشن سے تبدیل کیا جا سکتا ہے:

int x = 0;
x += 1; // x = 0 + 1 => x = 1
x += 1; // x = 1 + 1 => x = 2
x += 1; // x = 2 + 1 => x = 3

آپ اسائنمنٹ آپریٹر کو کسی بھی ریاضی کے آپریٹر کے ساتھ جوڑ سکتے ہیں:

int x = 0;
x += 10; // x = 0 + 10 => x = 10
x -= 5; // x = 10 - 5 => x = 5
x *= 5; // x = 5 * 5 => x = 25
x /= 5; // x = 25 / 5 => x = 5
x %= 3; // x = 5 % 3 => x = 2;

آئیے یہ ظاہر کرتے ہیں کہ آخری مثال کیسے کام کرتی ہے: بائنری آپریٹرز کے علاوہ، جاوا میں یونری ریاضی والے آپریٹرز ہیں۔ جدول 2. یونری ریاضی کے آپریٹرز: یونیری پلس اور مائنس کی مثال:

int x = 0;
x = (+5) + (+15); // Parentheses for clarity, it is possible without them
System.out.println("x = " + x);

int y = -x;
System.out.println("y = " + y);

اضافہ اور کمی کی کارروائیاں بنیادی طور پر آسان ہیں۔ پہلی صورت میں، متغیر میں 1 کا اضافہ ہوا ہے، دوسری صورت میں، متغیر میں 1 کی کمی ہوئی ہے۔ مثال ذیل میں دی گئی ہے:

int x = 9;
x++;
System.out.println(x); // 10

int y = 21;
y--;
System.out.println(y); // 20

ان آپریشنز کی دو قسمیں ہیں - پوسٹ فکس اور پریفکس۔ پہلی صورت میں، آپریٹر متغیر کے بعد، دوسری صورت میں، متغیر سے پہلے لکھا جاتا ہے۔ فرق صرف اتنا ہے جب انکریمنٹ یا ڈیکرمنٹ آپریشن کیا جاتا ہے۔ مندرجہ ذیل جدول میں مثال اور تفصیل۔ ہم کہتے ہیں کہ ہمارے پاس ایک متغیر ہے:

int a = 2;

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

int a = 1;
int b = 2;

boolean comparisonResult = a == b;
System.out.println("a == b :" + comparisonResult);

comparisonResult = a != b;
System.out.println("a != b :" + comparisonResult);

comparisonResult = a > b;
System.out.println("a >  b :" + comparisonResult);

comparisonResult = a >= b;
System.out.println("a >= b :" + comparisonResult);

comparisonResult = a < b;
System.out.println("a <  b :" + comparisonResult);

comparisonResult = a <= b;
System.out.println("a <= b :" + comparisonResult);

مظاہرہ:

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

آئیے ان میں سے ہر ایک کی منطقی کارروائیوں اور سچائی کی میزیں دیکھیں:

• نفی آپریشن ( NOT)؛
• کنکشن آپریشن، منطقی اور ( AND)
• منقطع آپریشن، منطقی یا ( OR)
• ماڈیولو اضافی آپریشن، خصوصی یا ( XOR)

نفی آپریٹر unary ہے اور ایک واحد آپرینڈ پر لاگو ہوتا ہے۔ دیگر تمام آپریشنز بائنری ہیں۔ آئیے ان کارروائیوں کی سچائی کی میزوں پر غور کریں۔ یہاں 0 جاوا میں غلط کے برابر ہے ، اور 1 سچ کے برابر ہے ۔ ٹیبل 5. نفی آپریٹر ٹروتھ ٹیبل (نہیں) جدول 6. کنکشن آپریٹر کی سچائی کی میز (AND) جدول 7. ڈسکشن آپریٹر کی سچائی کی میز (OR) جدول 8. ماڈیولو ایڈیشن آپریٹر کی سچائی کی میز (XOR) جاوا میں ایک ہی منطقی کارروائیاں ہیں:

• !- نفی آپریٹر؛
• &&- منطقی اور آپریٹر (مختصر)؛
• ||- منطقی یا آپریٹر (مختصر)؛
• &- بٹ وائز اور آپریٹر؛
• |- بٹ وائز یا آپریٹر؛
• ^- بٹ وائز خصوصی یا آپریٹر۔

آئیے تھوڑا سا آگے بٹ وائز اور شارٹ ہینڈ آپریٹرز کے درمیان فرق کو دیکھتے ہیں، جبکہ آئیے تمام سچ ٹیبلز کو جاوا کوڈ میں تبدیل کرتے ہیں۔

public class LogicDemo {

   public static void main(String[] args) {
    notExample();
    andExample();
    orExample();
    xorExample();
   }

   public static void notExample() {
    System.out.println("NOT EXAMPLE:");
    System.out.println("NOT false = " + !false);
       System.out.println("NOT true  = " + !true);
    System.out.println();
   }

   public static void andExample() {
    System.out.println("AND EXAMPLE:");
    System.out.println("false AND false = " + (false & false));
    System.out.println("false AND true  = " + (false & true));
    System.out.println("true  AND false = " + (true & false));
    System.out.println("true  AND true  = " + (true & true));
    System.out.println();
   }

   public static void orExample() {
    System.out.println("OR EXAMPLE:");
    System.out.println("false OR false = " + (false | false));
    System.out.println("false OR true  = " + (false | true));
    System.out.println("true  OR false = " + (true | false));
     System.out.println("true  OR true  = " + (true | true));
    System.out.println();
   }

   public static void xorExample() {
    System.out.println("XOR EXAMPLE:");
    System.out.println("false XOR false = " + (false ^ false));
    System.out.println("false XOR true  = " + (false ^ true));
    System.out.println("true  XOR false = " + (true ^ false));
    System.out.println("true  XOR true  = " + (true ^ true));
    System.out.println();
   }
}

یہ پروگرام دکھائے گا: NOT EXAMPLE: NOT false = سچ نہیں = سچ نہیں = غلط اور مثال: غلط اور غلط = جھوٹے جھوٹے اور سچے = جھوٹے سچ اور جھوٹے = جھوٹے سچے اور سچے = سچے یا مثال: غلط یا غلط = جھوٹے یا سچے = true true OR false = true true OR true = true XOR EXAMPLE: false XOR false = false false XOR true = true true XOR false = true true XOR true = false منطقی آپریٹرز صرف booleanمتغیرات پر لاگو ہوتے ہیں۔ ہمارے معاملے میں، ہم نے انہیں براہ راست اقدار پر لاگو کیا، لیکن آپ انہیں booleanمتغیرات کے ساتھ بھی استعمال کر سکتے ہیں: اور booleanاظہار کے لیے: اب، ہمارے پاس شارٹ ہینڈ آپریٹرز ( &&، ||) اور اسی طرح کے بٹ وائز آپریٹرز ( &، |) ہیں۔ ان میں کیا فرق ہے؟ سب سے پہلے، بٹ وائز کو عدد پر لاگو کیا جا سکتا ہے۔ اس بارے میں ہم تھوڑی دیر بعد بات کریں گے۔ اور دوسری بات یہ ہے کہ کچھ کا اختصار کیا جاتا ہے، جبکہ دوسرے نہیں ہوتے۔ یہ سمجھنے کے لیے کہ مخفف کیسا لگتا ہے، آئیے اظہار کو دیکھتے ہیں:

false AND x = ?
true OR x = ?

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

جاوا میں بٹ وائز آپریشنز

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

بائنری نمبر سسٹم میں نمبروں کی نمائندگی

نمبرز، کسی پروگرام میں کسی بھی دوسری معلومات کی طرح، بائنری کوڈ میں کمپیوٹر میموری میں محفوظ ہوتے ہیں۔ بائنری کوڈ صفر اور ایک کا مجموعہ ہے۔ ہر صفر یا ایک معلومات کی اکائی کی نمائندگی کرتا ہے جسے تھوڑا کہتے ہیں۔

ویکیپیڈیا کے مطابق:

تھوڑا سا (انگریزی بائنری ہندسوں سے - بائنری نمبر؛ الفاظ پر بھی ایک کھیل: انگریزی بٹ - ٹکڑا، ذرہ) معلومات کی مقدار کی پیمائش کی اکائی ہے۔ معلومات کا 1 بٹ ایک علامت یا سگنل ہے جس کے دو معنی ہو سکتے ہیں: آن یا آف، ہاں یا نہیں، زیادہ یا کم، چارج یا غیر چارج شدہ؛ بائنری سسٹم میں یہ 1 (ایک) یا 0 (صفر) ہے۔

بٹ وائز آپریٹرز کس قسم کے ڈیٹا کے ساتھ کام کرتے ہیں؟

جاوا میں بٹ وائز آپریشنز صرف انٹیجرز پر کیے جاتے ہیں۔ عدد کو کمپیوٹر میموری میں بٹس کے سیٹ کے طور پر محفوظ کیا جاتا ہے۔ ہم کہہ سکتے ہیں کہ کمپیوٹر کسی بھی معلومات کو بائنری نمبر سسٹم (بٹس کا ایک سیٹ) میں تبدیل کرتا ہے اور تب ہی اس کے ساتھ تعامل کرتا ہے۔ لیکن بائنری نمبر سسٹم کیسے کام کرتا ہے؟ اعشاریہ نمبر کے نظام میں ہمارے پاس صرف 10 علامتیں ہیں: 0، ​​1، 2، 3، 4، 5، 6، 7، 8، 9۔ ہم ان علامتوں کو شمار کرنے کے لیے استعمال کرتے ہیں۔ 9 کے بعد 10 آتا ہے، 19 - 20 کے بعد، 99 - 100 کے بعد، 749 - 750 کے بعد۔ یعنی، ہم دستیاب 10 علامتوں کا مجموعہ استعمال کرتے ہیں اور انہیں "صفر سے لنچ تک" شمار کرنے کے لیے استعمال کر سکتے ہیں۔ بائنری نمبر سسٹم میں، دس علامتوں کے بجائے صرف دو ہیں - 0، 1۔ لیکن ان علامتوں کو اسی اصول کے مطابق جوڑ کر جس طرح اعشاریہ نظام میں ہے، ہم غیر معینہ مدت تک شمار کر سکتے ہیں۔ آئیے اعشاریہ اور بائنری میں 0 سے 15 تک گنتی کا مظاہرہ کرتے ہیں: جیسا کہ آپ دیکھ سکتے ہیں، سب کچھ اتنا پیچیدہ نہیں ہے. بٹس کے علاوہ، معلومات کی دیگر مانوس اکائیاں ہیں - بائٹس ، کلو بائٹس ، میگا بائٹس ، گیگا بائٹس ، وغیرہ۔ آپ شاید جانتے ہوں گے کہ 1 بائٹ میں 8 بٹس ہوتے ہیں ۔ اس کا کیا مطلب ہے؟ اس کا مطلب ہے کہ ایک قطار میں 8 بٹس 1 بائٹ پر قبضہ کرتے ہیں۔ بائٹس کیا ہو سکتے ہیں اس کی مثالیں یہ ہیں:

00000000 - 1 byte
10110010 - 1 byte
01011011 - 1 byte

ایک بائٹ میں بٹس کے ممکنہ غیر دہرائے جانے والے امتزاج کی تعداد 256 (2 ⁸ = 256) ہے۔ لیکن آئیے جاوا کے قریب واپس آتے ہیں۔ اس طرح کی ایک عددی ڈیٹا کی قسم ہے - byte. یہ قسم -128 سے 127 تک کی قدریں لے سکتی ہے اور کمپیوٹر میموری میں ایک نمبر بالکل 8 بٹس یا 1 بائٹ لیتا ہے۔ byteاس قسم کا ایک نمبر بالکل 1 کمپیوٹر میموری لیتا ہے ۔ اور یہاں نام اتفاق سے نہیں ملتے ہیں۔ جیسا کہ ہمیں یاد ہے، 1 بائٹ 256 مختلف اقدار کو محفوظ کر سکتا ہے۔ اور ایک قسم کا نمبر byte256 مختلف اقدار (128 منفی، 127 مثبت اور 1 صفر) لے سکتا ہے۔ ہر نمبر کی قدر byteمیں آٹھ بٹس کا ایک منفرد سیٹ ہوتا ہے۔ یہ معاملہ صرف قسم کے ساتھ نہیں ہے byte، بلکہ تمام لازمی اقسام کے ساتھ ہے۔ قسم byteسب سے چھوٹی کے طور پر ایک مثال کے طور پر دیا جاتا ہے. نیچے دی گئی جدول میں جاوا کے انٹیجر کی تمام اقسام اور ان کے زیر قبضہ میموری کی جگہ دکھائی گئی ہے: قسم پر غور کریں int۔ یہ 2147483648 منفی اقدار، 2147483647 مثبت قدریں، اور ایک صفر محفوظ کر سکتا ہے۔ کل:

2147483648 + 2147483647 + 1 = 4294967296.

یہ قسم کمپیوٹر میموری میں 32 بٹس لیتی ہے۔ 32 صفر اور ایک کے سیٹ سے ممکنہ امتزاج کی تعداد یہ ہے:

232 = 4294967296.

اتنی ہی تعداد جتنی قدروں کی تعداد اس قسم کی ہو سکتی ہے int۔ یہ ڈیٹا کی قسم کی اقدار کی حد اور اس کے سائز (میموری میں بٹس کی تعداد) کے درمیان تعلق کا صرف ایک مظاہرہ ہے۔ جاوا میں کسی بھی قسم کی کسی بھی تعداد کو بائنری میں تبدیل کیا جا سکتا ہے۔ آئیے دیکھتے ہیں کہ یہ جاوا زبان کا استعمال کرتے ہوئے کتنی آسانی سے کیا جا سکتا ہے۔ ہم قسم کی مثال سے سیکھیں گے int۔ اس قسم کی اپنی ریپر کلاس ہے Integer۔ اور اس کے پاس ایک ہے toBinaryString، جو ہمارے لیے تمام کام کرے گا: Voila - یہ اتنا پیچیدہ نہیں ہے۔ لیکن پھر بھی، کچھ واضح کرنے کی ضرورت ہے. intنمبر 32 بٹس لیتا ہے. لیکن جب ہم اوپر دی گئی مثال میں نمبر 10 پرنٹ کرتے ہیں، تو ہمیں کنسول میں 1010 نظر آتا ہے۔اس کی وجہ یہ ہے کہ لیڈنگ زیرو پرنٹ نہیں ہوتے ہیں۔ اگر وہ دکھائے جاتے تو 1010 کے بجائے ہم کنسول 00000000000000000000000000000001010 میں دیکھیں گے۔ لیکن ادراک کی آسانی کے لیے، تمام معروف صفر کو چھوڑ دیا جاتا ہے۔ اتنا مشکل نہیں جب تک کہ آپ اپنے آپ سے نہ پوچھیں: منفی نمبروں کا کیا ہوگا؟ یہ صرف بائنری سسٹم میں معلومات کو سمجھتا ہے۔ یہ پتہ چلتا ہے کہ مائنس کے نشان کو بھی بائنری کوڈ میں لکھنے کی ضرورت ہے۔ یہ براہ راست یا تکمیلی کوڈ کا استعمال کرتے ہوئے کیا جا سکتا ہے۔

براہ راست کوڈ

بائنری نمبر سسٹم میں نمبروں کی نمائندگی کرنے کا ایک طریقہ، جس میں سب سے اہم بٹ (بائیں طرف کا بٹ) نمبر کے نشان کے لیے مختص کیا جاتا ہے۔ اگر نمبر مثبت ہے تو سب سے بائیں بٹ 0 لکھا جاتا ہے، اگر منفی - 1۔ آئیے ایک مثال کے طور پر 8 بٹ نمبر کا استعمال کرتے ہوئے اسے دیکھتے ہیں: نقطہ نظر سادہ اور اصولی طور پر قابل فہم ہے۔ تاہم، اس کے نقصانات ہیں: ریاضی کے عمل کو انجام دینے میں مشکلات۔ مثال کے طور پر، منفی اور مثبت اعداد کے اضافے کے ساتھ۔ انہیں اس وقت تک جوڑا نہیں جا سکتا جب تک کہ اضافی ہیرا پھیری نہ کی جائے۔

اضافی کوڈ

اضافی کوڈ استعمال کرکے، آپ براہ راست کوڈ کے نقصانات سے بچ سکتے ہیں۔ کسی نمبر کا اضافی کوڈ حاصل کرنے کے لیے ایک سادہ الگورتھم ہے۔ آئیے نمبر -5 کے لیے اضافی کوڈ حاصل کرنے کی کوشش کرتے ہیں۔ آئیے بائنری نمبر سسٹم میں دو کے تکمیلی کوڈ کا استعمال کرتے ہوئے اس نمبر کی نمائندگی کرتے ہیں۔ مرحلہ 1۔ ہم براہ راست کوڈ کا استعمال کرتے ہوئے منفی نمبر کی نمائندگی حاصل کرتے ہیں۔ -5 کے لیے یہ 10000101 ہوگا۔ مرحلہ 2۔ نشانی ہندسے کے علاوہ تمام ہندسوں کو الٹ دیں۔ آئیے تمام زیرو کو ایک سے بدلتے ہیں، اور سب سے بائیں بٹ کے علاوہ ہر جگہ صفر کے ساتھ۔

10000101 => 11111010

مرحلہ 3۔ نتیجے میں آنے والی قدر میں ایک شامل کریں:

11111010 + 1 = 11111011

تیار. ہمیں دو کے تکمیلی کوڈ کا استعمال کرتے ہوئے بائنری نمبر سسٹم میں -5 کی قدر ملی۔ یہ مندرجہ ذیل مواد کو سمجھنے کے لیے اہم ہے، کیونکہ جاوا منفی نمبروں کو بٹس میں ذخیرہ کرنے کے لیے دو کے تکمیلی کوڈ کا استعمال کرتا ہے۔

بٹ وائز آپریشنز کی اقسام

اب جب کہ ہم نے تمام تعارف کر لیا ہے، آئیے جاوا میں بٹ وائز آپریشنز کے بارے میں بات کرتے ہیں۔ بٹ وائز آپریشن انٹیجرز پر کیا جاتا ہے اور اس کا نتیجہ ایک انٹیجر ہوتا ہے۔ اس عمل میں، نمبر کو بائنری میں تبدیل کر دیا جاتا ہے، ہر بٹ پر ایک آپریشن کیا جاتا ہے، اور نتیجہ واپس اعشاریہ میں تبدیل ہو جاتا ہے۔ آپریشنز کی فہرست نیچے دی گئی جدول میں ہے: جیسا کہ ہم پہلے ہی جان چکے ہیں، نمبرز کو بٹس کے سیٹ کے طور پر دکھایا جا سکتا ہے۔ Bitwise آپریشنز بالکل اس طرح کی نمائندگی کے ہر بٹ پر آپریشن کرتے ہیں۔ آئیے لیتے ہیں NOT،،، ۔ یاد رکھیں کہ ہم نے حال ہی میں صرف منطقی کاموں کے لیے سچائی کی میزیں دیکھیں۔ اس صورت میں، انٹیجر کے ہر بٹ پر وہی آپریشن لاگو ہوتے ہیں۔ ANDORXOR

Bitwise unary operator NOT ~

یہ آپریٹر تمام زیرو کو ایک سے اور تمام کو صفر سے بدل دیتا ہے۔ ہم کہتے ہیں کہ ہمارے پاس اعشاریہ اشارے میں نمبر 10 ہے۔ بائنری میں، یہ نمبر 1010 ہے۔ اگر ہم اس نمبر پر unary bitwise negation operator کا اطلاق کرتے ہیں، تو ہمیں کچھ اس طرح ملتا ہے: آئیے ایک نظر ڈالیں کہ یہ جاوا کوڈ میں کیسا لگتا ہے:

public static void main(String[] args) {
   int a = 10;

   System.out.println(" a = " + a + "; binary string: " + Integer.toBinaryString(a));
   System.out.println("~a = " + ~a + "; binary string: " + Integer.toBinaryString(~a));
}

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

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

یہ آپریٹر دو نمبروں پر لاگو ہوتا ہے۔ ANDیہ ہر نمبر کے بٹس کے درمیان ایک آپریشن کرتا ہے ۔ آئیے ایک مثال دیکھیں: یہ آپریشن دو نمبروں پر کیا جاتا ہے۔ جاوا کوڈ میں مثال:

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

یا دو نمبروں پر لاگو ہوتا ہے۔ یہ ہر نمبر کے بٹس کے درمیان ایک OR آپریشن کرتا ہے: اب آئیے ایک نظر ڈالیں کہ یہ IDEA میں کیسا نظر آئے گا:

بٹ وار آپریشن، خصوصی یا (XOR)

آئیے اسی مثال کو دیکھتے ہیں، لیکن ایک نئے آپریشن کے ساتھ: مثال کوڈ:

Bitwise بائیں شفٹ کریں۔

یہ آپریٹر دو آپرینڈز پر لاگو ہوتا ہے، یعنی آپریشن میں، x << yنمبر کے بٹس پوزیشن کو بائیں طرف xمنتقل کر دیتے ہیں ۔ yاس کا کیا مطلب ہے؟ آئیے آپریشن کی مثال دیکھتے ہیں 10 << 1 آپریشن کا نتیجہ ڈیسیمل سسٹم میں نمبر 20 ہوگا۔ جیسا کہ آپ اوپر دیے گئے خاکے سے دیکھ سکتے ہیں، تمام بٹس کو 1 سے بائیں طرف منتقل کر دیا جاتا ہے۔ اس آپریشن کے دوران، سب سے اہم بٹ (بائیں طرف کا بٹ) کی قدر ختم ہو جاتی ہے۔ اور سب سے کم اہم بٹ (سب سے دائیں بٹ) صفر سے بھرا ہوا ہے۔ آپ اس آپریشن کے بارے میں کیا کہہ سکتے ہیں؟

1. کسی نمبر کے بٹس کو بٹس Xکے ذریعے Nبائیں طرف منتقل کرکے، ہم نمبر کو X2 ^N سے ضرب کرتے ہیں ۔

   یہاں ایک مثال ہے:

2. لیکن! نمبر کا نشان تبدیل ہو سکتا ہے اگر قدر 1 والا بٹ سب سے بائیں پوزیشن لے۔

3. اگر آپ غیر معینہ مدت تک بائیں جانب شفٹ ہوتے ہیں، تو نمبر صرف 0 میں بدل جائے گا۔ آئیے پوائنٹس 2 اور 3 کا مظاہرہ کریں:

Bitwise دائیں طرف شفٹ کریں۔

یہ آپریٹر دو آپرینڈز پر لاگو ہوتا ہے۔ وہ. آپریشن میں x >> y، نمبر کے بٹس پوزیشن کو دائیں طرف xمنتقل کر دیں گے ۔ yآئیے ایک اور مثال دیکھتے ہیں۔ آئیے منصوبہ بندی کے ساتھ آپریشن کا تجزیہ کرتے ہیں 10 >> 1۔ آئیے نمبر 10 کی ایک پوزیشن کے تمام بٹس کو دائیں طرف منتقل کریں: شفٹ آپریشن کے دوران، ہم صحیح بٹس کھو دیتے ہیں۔ وہ بس غائب ہو جاتے ہیں۔ سب سے بائیں بٹ نمبر کا نشان ہے (0 مثبت ہے، 1 منفی ہے)۔ لہذا، حتمی قیمت میں اسے اصل نمبر کی طرح رکھا گیا ہے۔ منفی نمبر کے ساتھ مثال: سب سے دائیں بٹ کھو گیا ہے، اور سب سے بائیں بٹ کو اصل نمبر سے نقل کیا گیا ہے، نمبر کے اعزازی نشان کے طور پر۔ IDEA میں یہ سب کیسے کیا جائے؟ اصولی طور پر، کچھ بھی پیچیدہ نہیں ہے، بس اسے لے لو اور اسے منتقل کرو: ابھی. آپ ان نمبروں کے بارے میں کیا کہہ سکتے ہیں جو دائیں طرف منتقل ہوتے ہیں؟ وہ 2 سے قابل تقسیم ہیں۔ ہر بار جب ہم ایک بٹ کو دائیں طرف منتقل کرتے ہیں، ہم اصل نمبر کو 2 سے تقسیم کرتے ہیں۔ اگر نمبر 2 سے تقسیم نہیں ہوتا ہے، تو نتیجہ مائنس انفینٹی (نیچے) کی طرف گول ہو جائے گا۔ لیکن یہ صرف اس صورت میں کام کرتا ہے جب ہم بٹس کو بالکل 1 سے شفٹ کریں۔ اور اگر 2 بٹس سے، 4 سے تقسیم کریں۔ 3 بٹس سے، 8 سے تقسیم کریں۔ 4 بٹس سے، 16 سے تقسیم کریں۔ دیکھیں؟ 2 کی طاقتیں... جب ہم کسی عدد کو بٹس کے ذریعے دائیں Xطرف شفٹ کرتے ہیں N، تو ہم نمبر کو X2 سے 2 کی طاقت سے تقسیم کرتے ہیں N۔ مظاہرہ:

public class BitOperationsDemo {

   public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {

        int shiftOperationResult = 2048 >> i;
        int devideOperationResult = 2048 / (int) Math.pow(2, i);


           System.out.println(shiftOperationResult + " - " + devideOperationResult);
    }

   }

}

یہاں کیا ہو رہا ہے؟

1. ایک لوپ جس میں متغیر i کو 1 سے 10 تک بڑھایا جاتا ہے۔

2. ہر تکرار میں ہم 2 اقدار کا حساب لگاتے ہیں:

• ہم متغیر میں shiftOperationResultنمبر 2048 کو i بٹس کے ذریعے دائیں طرف منتقل کرنے کا نتیجہ لکھتے ہیں۔

• devideOperationResultہم نمبر 2048 کو i پاور میں 2 سے تقسیم کرنے کا نتیجہ متغیر میں لکھتے ہیں ۔

3. ہم دو حاصل شدہ اقدار کو جوڑوں میں ظاہر کرتے ہیں۔

پروگرام پر عمل کرنے کا نتیجہ درج ذیل ہے: 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

صفر پیڈنگ کے ساتھ بٹ وار دائیں شفٹ

جبکہ ایک عام بٹ رائٹ شفٹ نمبر کے نشان کو محفوظ رکھتی ہے (سب سے اہم بٹ اپنی قدر کو برقرار رکھتا ہے)، صفر بھرنے والی رائٹ شفٹ ایسا نہیں کرتی ہے۔ اور سب سے اہم بٹ صفر سے بھرا ہوا ہے۔ آئیے دیکھتے ہیں کہ یہ کیسا لگتا ہے:

جاوا میں آپریشنز کی ترجیح

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

استعمال کی مفید مثالیں۔

عدد کی برابری کا تعین کرنا

ایک صف میں زیادہ سے زیادہ عنصر تلاش کرنا

کم از کم عنصر تلاش کرنے کے لیے، موازنہ کے نشان کو صحیح جگہ پر تبدیل کریں۔