جاوا آپريٽرز جو تعارف: منطقي، رياضي، Bitwise

اچو ته جاوا ۾ عملن بابت ڳالهايون: عددي، منطقي، bitwise. اهو هڪ نظرياتي بنياد آهي جيڪو ضرور سکڻ جي ضرورت آهي ته ڪيئن پروگرام ڪجي.

• جاوا ۾ آپريٽرز جا ڪهڙا قسم آهن؟
• جاوا آپريٽر جاوا رش ڪورس ۾
• جاوا ۾ نمبر آپريشن
• جاوا ۾ منطقي آپريشن
• جاوا ۾ Bitwise آپريشن
• جاوا ۾ آپريشن جي اڳڀرائي
• استعمال جا مفيد مثال

جاوا ۾ آپريٽرز جا ڪهڙا قسم آهن؟

ڪنهن به آپريشن لاءِ اسان کي گهٽ ۾ گهٽ ٻن شين جي ضرورت آهي:

• آپريٽر
• ڪم ڪار

هڪ آپريٽر جو هڪ مثال ٻه نمبر شامل ڪرڻ جي عمل ۾ هڪ سادي پلس هوندو. ۽ هڪ ٻئي ۾ شامل ڪيل نمبر هن ڪيس ۾ ڪم ڪندڙ هوندا. تنهن ڪري، آپريٽرز جي مدد سان، اسان هڪ يا وڌيڪ آپريشنز تي آپريشن ڪندا آهيون. آپريٽر جيڪي ٻن آپريشنز تي ڪم ڪن ٿا انهن کي بائنري سڏيو ويندو آهي. مثال طور، ٻه انگ شامل ڪرڻ. آپريٽر جيڪي هڪ واحد آپرينڊ تي آپريشن ڪن ٿا انهن کي غيرري سڏيو ويندو آهي. مثال طور، هڪ unary مائنس.

جاوا آپريٽر جاوا رش ڪورس ۾

ڪيترائي ليڪچر جاوا آپريٽرز لاءِ وقف ڪيا ويا آهن پهرين جستجو جي چوٿين سطح تي - Java Syntax. خاص طور تي، مشروط آپريٽرز جهڙوڪ بوليان . ڪورس ۾ 22 ڪم شامل آھن جيڪي توھان جي ڪم کي سمجھڻ ۾ مدد ڏين ٿا موازنہ آپريٽرز، مشروط آپريٽرز، ۽ منطقي آپريٽرز.

جاوا ۾ نمبر آپريشن

سڀ کان وڌيڪ عام آپريشن جيڪو پروگرامر نمبرن تي انجام ڏئي ٿو هڪ متغير کي عددي قدر تفويض ڪري رهيو آهي. هوء، آپريٽر وانگر، =توهان کي واقف آهي:

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

اتي پڻ رياضياتي عمل آهن. اهي بائنري رياضياتي آپريٽرز استعمال ڪندي ڪيا ويا آهن: جدول 1. بائنري رياضي آپريٽرز پهرين چار آپريٽرز کي ڪو به سوال نه اٿارڻ گهرجي: سڀ ڪجهه ساڳيو آهي جيئن رياضي ۾. آخري آپريٽر، باقي ڊويزن، پڻ ڪجھ به پيچيده نه ڪندو آھي. مثال طور، جيڪڏهن اسان 24 کي 7 سان ورهايون ٿا، اسان کي 3 مڪمل انگ ۽ 3 باقي آهن. اهو باقي آهي ته هي آپريٽر واپس ڪندو:

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

هتي مثال آهن سرڪاري Oracle دستاويزي سائيٽ مان: هي پروگرام هيٺ ڏنل آئوٽ ڪندو: 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).

نفي آپريٽر يونيري آهي ۽ هڪ واحد آپرينڊ تي لاڳو ٿئي ٿو. ٻيا سڀئي عمل بائنري آھن. اچو ته انهن عملن جي سچائي جدولن تي غور ڪريون. هتي 0 جاوا ۾ غلط جي برابر آهي ، ۽ 1 صحيح جي برابر آهي . جدول 5. ناڪاري آپريٽر ٽرٿ ٽيبل (نه) جدول 6. ڪانڪشن آپريٽر جي سچائي جدول (AND) جدول 7. ڊسجنڪشن آپريٽر جي سچائي جدول (OR) جدول 8. ٽرٿ ٽيبل آف ماڊلو ايڊيشن آپريٽر (XOR) جاوا ساڳيا منطقي عمل آهن:

• !- منفي آپريٽر؛
• &&- منطقي ۽ آپريٽر (مختصر)؛
• ||- منطقي يا آپريٽر (مختصر)؛
• &- bitwise ۽ آپريٽر؛
• |- bitwise يا آپريٽر؛
• ^- bitwise خاص يا آپريٽر.

اچو ته هيٺ ڏنل bitwise ۽ شارٽ هينڊ آپريٽرز جي وچ ۾ فرق کي ڏسو، جڏهن ته اچو ته سڀني سچي جدولن کي جاوا ڪوڊ ۾ تبديل ڪريون:

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 = سچ نه = سچو نه = غلط ۽ مثال: غلط ۽ غلط = ڪوڙو غلط ۽ سچو = ڪوڙو سچو ۽ غلط = غلط سچو ۽ سچو = سچو يا مثال: غلط يا غلط = غلط يا سچو = سچو سچو يا غلط = سچو سچو يا سچو = سچو XOR EXAMPLE: false XOR false = ڪوڙو غلط XOR سچو = سچو سچو XOR غلط = سچو سچو XOR سچو = غلط منطقي آپريٽر صرف متغيرن تي لاڳو ٿين ٿا boolean. اسان جي حالت ۾، اسان انھن کي سڌو سنئون قدرن تي لاڳو ڪيو، پر توھان انھن کي booleanمتغير سان پڻ استعمال ڪري سگھو ٿا: ۽ booleanاظهار لاءِ: هاڻي، اسان وٽ شارٽ هينڊ آپريٽر ( &&, ||) ۽ ساڳيا bitwise آپريٽرز ( &, |) آهن. انهن جي وچ ۾ ڪهڙو فرق آهي؟ پهريون، bitwise integers تي لاڳو ڪري سگھجي ٿو. اسان ان بابت ٿوري دير بعد ڳالهائينداسين. ۽ ٻيو، ڪجهه مختصر آهن، جڏهن ته ٻيا نه آهن. سمجھڻ لاءِ ته مخفف ڪھڙي طرح نظر اچي ٿو، اچو ته بيان کي ڏسو:

false AND x = ?
true OR x = ?

هي xڪنهن به Boolean قدر وٺي سگھي ٿو. ۽ عام طور تي، منطق ۽ سچ جي جدولن جي قانونن جي مطابق، قطع نظر ته اهو x صحيح آهي يا غلط ، پهرين اظهار جو نتيجو غلط ٿيندو ، ۽ ٻيو نتيجو صحيح ٿيندو . ڏس. ڪڏهن ڪڏهن هڪ اظهار جو نتيجو پهرين اوپيرينڊ مان حساب ڪري سگهجي ٿو. اھو اھو آھي جيڪو مخفف آپريٽرز &&۽ ||. مٿي بيان ڪيل بيانن سان ملندڙ جلندڙ بيانن ۾، اهي ٻئي اوپيرينڊ جي قيمت جو اندازو نٿا ڪن. هتي هڪ ننڍڙو مثال آهي: شارٽ هينڊ آپريٽرز جي صورت ۾، اظهار جي ٻئي حصي جو اندازو نه ڪيو ويو آهي. پر اهو صرف تڏهن ٿئي ٿو جڏهن اظهار جو نتيجو اڳ ۾ ئي پهرين آپريشن کان پڌرو آهي.

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

خير، هتي اسان کي سڀ کان دلچسپ حصو اچي ٿو: bitwise آپريشن. جيئن ته نالو مشورو ڏئي ٿو، اهي آپريشن آهن جيڪي بٽ تي ڪيا ويا آهن. پر ان کان اڳ جو اسان هن موضوع تي غور ڪيو، اهو لاڳاپيل علائقن بابت ڳالهائڻ جي قابل آهي.

بائنري نمبر سسٽم ۾ انگن جي نمائندگي

نمبر، ڪنهن پروگرام ۾ ڪنهن ٻئي معلومات وانگر، بائنري ڪوڊ ۾ ڪمپيوٽر جي ياداشت ۾ محفوظ ٿيل آهن. بائنري ڪوڊ صفر ۽ هڪ جو هڪ سيٽ آهي. هر صفر يا هڪ معلومات جي هڪ يونٽ جي نمائندگي ڪري ٿو جنهن کي بٽ سڏيو ويندو آهي.

وڪيپيڊيا جي مطابق:

A bit (انگريزي بائنري انگن مان - بائنري نمبر؛ پڻ لفظن تي راند: انگريزي bit - piece، particle) معلومات جي مقدار جي ماپ جو هڪ يونٽ آهي. معلومات جو 1 بٽ هڪ علامت يا سگنل آهي جنهن جا ٻه مطلب وٺي سگهن ٿا: آن يا آف، ها يا نه، هاءِ يا گهٽ، چارج ٿيل يا اڻ چارج ٿيل؛ بائنري سسٽم ۾ اهو 1 (هڪ) يا 0 (صفر) آهي.

bitwise آپريٽرز ڪهڙي قسم جي ڊيٽا سان ڪم ڪن ٿا؟

جاوا ۾ Bitwise آپريشن صرف انٽيجرز تي ڪيا ويندا آھن. Integers ڪمپيوٽر جي ياداشت ۾ ذخيرو ٿيل آهن بٽس جي هڪ سيٽ جي طور تي. اسان اهو چئي سگهون ٿا ته ڪمپيوٽر ڪنهن به معلومات کي بائنري نمبر سسٽم (بٽ جو هڪ سيٽ) ۾ تبديل ڪري ٿو ۽ صرف ان سان رابطو ڪري ٿو. پر بائنري نمبر سسٽم ڪيئن ڪم ڪندو آهي؟ ڊيسيمل نمبر سسٽم ۾ اسان وٽ صرف 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 جي بدران اسان ڪنسول 00000000000000000000000000000000000000000000001010 ۾ ڏسندا سين. پر سمجهه جي آسانيءَ لاءِ، سڀ اڳواٽ صفر ختم ڪيا ويا آهن. اهو ڏکيو نه آهي جيستائين توهان پنهنجو پاڻ کان پڇو: منفي نمبرن بابت ڇا؟ اهو صرف بائنري سسٽم ۾ معلومات سمجهي ٿو. اهو ظاهر ٿئي ٿو ته مائنس نشاني پڻ بائنري ڪوڊ ۾ لکڻ جي ضرورت آهي. اهو سڌو يا مڪمل ڪوڊ استعمال ڪندي ڪري سگهجي ٿو.

سڌو ڪوڊ

بائنري نمبر سسٽم ۾ انگن جي نمائندگي ڪرڻ جو هڪ طريقو، جنهن ۾ سڀ کان اهم بٽ (کاٻي پاسي وارو سا) نمبر جي نشاني لاءِ مختص ڪيو ويو آهي. جيڪڏهن انگ مثبت آهي، سڀ کان کاٻي پاسي 0 لکيل آهي، جيڪڏهن منفي - 1. اچو ته ان کي 8-bit نمبر استعمال ڪندي مثال طور ڏسو: طريقو سادو آهي، اصول ۾، سمجھڻ وارو. تنهن هوندي به، ان جا نقصان آهن: رياضياتي عملن کي انجام ڏيڻ ۾ مشڪلات. مثال طور، منفي ۽ مثبت انگن جي اضافي سان. انهن کي فولڊ نه ٿو ڪري سگهجي جيستائين اضافي ڦيرڦار نه ڪيو وڃي.

اضافي ڪوڊ

اضافي ڪوڊ استعمال ڪندي، توهان سڌو ڪوڊ جي نقصانن کان پاسو ڪري سگهو ٿا. ھڪڙي نمبر جي اضافي ڪوڊ حاصل ڪرڻ لاء ھڪڙو سادي الگورتھم آھي. اچو ته ڪوشش ڪريون اضافي ڪوڊ حاصل ڪرڻ لاءِ نمبر -5. اچو ته هن نمبر کي بائنري نمبر سسٽم ۾ ٻن ڪمپليمينٽ ڪوڊ استعمال ڪندي ڏيکاريون. قدم 1. اسان سڌو ڪوڊ استعمال ڪندي منفي نمبر جي نمائندگي حاصل ڪندا آهيون. -5 لاءِ اهو ٿيندو 10000101. قدم 2. سڀني انگن کي ڦيرايو سواءِ نشاني جي عدد جي. اچو ته سڀني صفرن کي هڪ سان تبديل ڪريون، ۽ انهن کي هر هنڌ صفر سان مٽائي ڇڏيون سواءِ کاٻي پاسي واري سا.

10000101 => 11111010

مرحلا 3. ھڪڙي شامل ڪريو نتيجي جي قيمت ۾:

11111010 + 1 = 11111011

تيار. اسان ٻن جي مڪمل ڪوڊ استعمال ڪندي بائنري نمبر سسٽم ۾ -5 جي قيمت حاصل ڪئي. ھي ھيٺين مواد کي سمجھڻ لاءِ ضروري آھي، ڇاڪاڻ⁠تہ جاوا ٻن جو ڪمپليمينٽ ڪوڊ استعمال ڪري ٿو ناڪاري انگن کي بٽ ۾ رکڻ لاءِ.

bitwise آپريشن جا قسم

هاڻي ته اسان سڀني تعارفن سان ڊيل ڪيو آهي، اچو ته جاوا ۾ bitwise آپريشن بابت ڳالهايون. bitwise آپريشن انٽيجرز تي ڪيو ويندو آهي ۽ ان جو نتيجو هڪ عدد هوندو آهي. عمل ۾، نمبر بائنري ۾ تبديل ڪيو ويو آهي، هڪ آپريشن هر بٽ تي ڪيو ويندو آهي، ۽ نتيجو واپس ڊيسيمل ڏانهن تبديل ڪيو ويندو آهي. عملن جي فهرست ھيٺ ڏنل جدول ۾ آھي: جيئن ته اسان اڳ ۾ ئي ڳولي چڪا آھيون، انگن کي بٽ جي ھڪڙي سيٽ جي طور تي پيش ڪري سگھجي ٿو. Bitwise آپريشنز اهڙي نمائندگي جي هر بٽ تي آپريشن انجام ڏين ٿا. اچو ته وٺون NOT،،، . ياد رهي ته اسان تازو ڏٺو آهي سچائي جدولن کي صرف منطقي ڪمن لاءِ. انهي حالت ۾، ساڳيا عمل لاڳو ٿين ٿا انٽيجر جي هر بٽ تي. ANDORXOR

Bitwise unary operator NOT ~

هي آپريٽر سڀني صفر کي هڪ سان مٽائي ٿو، ۽ سڀني کي صفر سان. اچو ته چئو ته اسان وٽ نمبر 10 آهي decimal notation ۾. بائنري ۾، هي نمبر 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));
}

هاڻي اچو ته ڏسو ته ڪنسول ۾ ڇا ڏيکاريل آهي: پهرين لڪير ۾ اسان حاصل ڪئي قدر بائنري نمبر سسٽم ۾ بغير اڳوڻو صفر. جيتوڻيڪ اسان انهن کي نه ڏسندا آهيون، اهي اتي آهن. اهو ثابت ٿئي ٿو ته ٻئي لڪير، جنهن ۾ سڀني بٽ کي ريورس وارن ۾ تبديل ڪيو ويو آهي. اهو ئي سبب آهي ته اسان ڪيتريون ئي معروف يونٽ ڏسون ٿا. اهي اڳوڻو اڳوڻو صفر آهن جن کي مرتب ڪندڙ طرفان نظرانداز ڪيو ويو جڏهن پهرين لائن تي ڇپيل هئي. هتي هڪ ننڍڙو پروگرام آهي جيڪو پڻ ڏيکاري ٿو اڳوڻو صفر واضح ڪرڻ لاء.

Bitwise ۽ آپريٽر

هي آپريٽر ٻن نمبرن تي لاڳو ٿئي ٿو. اهو ANDهر نمبر جي بٽ جي وچ ۾ هڪ آپريشن انجام ڏئي ٿو. اچو ته هڪ مثال ڏسو: هي آپريشن ٻن نمبرن تي ڪيو ويندو آهي. جاوا ڪوڊ ۾ مثال:

Bitwise يا آپريٽر

يا ٻن نمبرن تي لاڳو ٿئي ٿو. اهو هر نمبر جي بٽ جي وچ ۾ هڪ OR آپريشن ڪري ٿو: هاڻي اچو ته هڪ نظر رکون ته اهو IDEA ۾ ڇا ٿيندو:

Bitwise آپريشن، خاص يا (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 جي طاقت سان ورهائيندا آهيون 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 bits ذريعي ڦيرائڻ جو نتيجو؛

• devideOperationResultاسان 2048 نمبر کي 2 سان ورهائڻ جو نتيجو لکون ٿا i پاور کي متغير ۾ .

3. اسان ٻن حاصل ڪيل قيمتن کي جوڑوں ۾ ڏيکاريون ٿا.

پروگرام تي عمل ڪرڻ جو نتيجو هن ريت آهي: 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

Bitwise ساڄي شفٽ صفر پيڊنگ سان

جڏهن ته هڪ عام ساڄي شفٽ نمبر جي نشاني کي محفوظ ڪري ٿو (سڀ کان وڌيڪ اهم سا پنهنجي قيمت کي برقرار رکي ٿو)، هڪ صفر ڀريو ساڄي شفٽ نه آهي. ۽ سڀ کان اهم سا صفر سان ڀريو پيو آهي. اچو ته ڏسو ته اهو ڇا ٿو لڳي:

جاوا ۾ آپريشن جي اڳڀرائي

رياضي وانگر، جاوا ۾ عملن جي ترجيح آهي. هيٺ ڏنل جدول ڏيکاري ٿو ترجيح (سڀ کان گھٽ کان گھٽ تائين) عملن جي جن تي اسان غور ڪيو.

استعمال جا مفيد مثال

عدد جي برابري جو تعين ڪرڻ

هڪ صف ۾ وڌ ۾ وڌ عنصر ڳولڻ

گھٽ ۾ گھٽ عنصر ڳولڻ لاء، صرف صحيح جاء تي مقابلي جي نشاني کي تبديل ڪريو.