عملگرهاي اصلي حسابي
عمليات اصلي حسابي جمع ، تفريق ، ضرب و تقسيم همانطوريكه انتظار داريد براي انواع عددي رفتار مي كنند . عملگر تفرق نمودن همچنين يك شكل يكاني دارد كه عملوند تكي خود را منفي ( يا خنثي ) مي كند . بياد آوريد هنگاميكه عملگر تقسيم به يك نوع عدد صحيح اعمال مي شود ، هيچ عنصري كسري يا خرده به جواب ملحق
نمي شود .

برنامه ساده بعدي نشاندهنده عملگرهاي حسابي است . اين برنامه همچنين تفاوت بين تقسيم اعشاري و تقسيم عدد صحيح را توضيح مي دهد .

+ // Demonstrate the basic arithmetic operators.
+ class BasicMath {
+ public static void main(String args[] ){
+ // arithmetic using integers
+ System.out.println("Integer Arithmetic");
+ int a = 1 + 1;
+ int a = a * 3;
+ int a = b / 4;
+ int a = c - a;
+ int a =- d;
+ System.out.println("a = " + a);
+ System.out.println("a = " + b);
+ System.out.println("a = " + c);
+ System.out.println("a = " + d);
+ System.out.println("a = " + e);
+
+ // arithmetic using doubles
+ System.out.println("\nFloating Point Arithmetic");
+ double da = 1 + 1;
+ double db = da * 3;
+ double dc = db / 4;
+ double dd = dc - a;
+ double de =- dd;
+ System.out.println("da = " + da);
+ System.out.println("db = " + db);
+ System.out.println("dc = " + dc);
+ System.out.println("dd = " + dd);
+ System.out.println("de = " + de);
+ }
+ }



خروجي اين برنامه بقرار زير مي باشد :

integer Arithmetic
a=2
b=6
c=1
d=-1
e=1
floating point arithmetic
da=2
db=6
dc=1.5
dd=-0.5
de=0.5

عملگر تعيين باقيمانده The Modulus operator

عملگر تعيين باقيمانده يعني % ، باقيمانده يك عمليات تقسيم را برمي گرداند.
اين عملگر براي انواع عدد اعشاري و انواع عدد صحيح قابل استفاده است . ( اما در C++/C اين عملگر فقط در مورد انواع عدد صحيح كاربرد دارد . ) برنامه بعدي نشان دهنده عملگر % مي باشد :

+ // Demonstrate the % operator.
+ class Modulus {
+ public static void main(String args[] ){
+ int x = 42;
+ double y = 42.3;
+
+ System.out.println("x mod 10 = " + x % 10);
+ System.out.println("y mod 10 = " + y % 10);
+ }
+ }



هنگاميكه اين برنامه را اجرا مي كنيد ، خروجي زير حاصل مي شود :

x mod 10=2
y mod 10=2.3




عملگرهاي انتساب حسابي Arithmetic Assignment operators جاوا عملگرهاي ويژه اي را تدارك ديده كه با استفاده از آنها مي توان يك عمليات حسابي را با يك انتساب تركيب نمود . احتمالا" مي دانيد كه دستوراتي نظير
مورد زير در برنامه نويسي كاملا" رايج هستند :

+ a = a + 4;

در جاوا ، مي توانيد اين دستور را بصورت ديگري دوباره نويسي نماييد :
+ a += 4;

اين روايت جديد از عملگر انتساب += استفاده مي كند هر دو دستورات يك عمل واحد را انجام مي دهند : آنها مقدار aرا 4ا واحد افزايش مي دهند .

اكنون مثال ديگري را مشاهده نماييد :
+ a = a % 2;

كه مي توان آن را بصورت زير نوشت :
+ a %= 2;

در اين حالت %= باقيمانده a/2 را گرفته و حاصل را مجددا"در aر قرار مي دهد.
عملگرهاي انتسابي براي كليه عملگرهاي حسابي و دودوئي ( باينري ) وجود دارند .

بنابراين هر دستور با شكل :
Var = var op expression;

عبارت عملگر متغير متغير
را مي توان بصورت زير دوباره نويسي نمود :
var op = expression

عبارت عملگر متغير
عملگرهاي انتساب دو مزيت را بوجود مي آورند . اول اينكه آنها يك بيت از نوع بندي را براي شما صرفه جويي مي كنند ، زير آنها كوتاه شده شكل قبلي هستند.

دوم اينكه آنها توسط سيستم حين اجراي جاوا بسيار كاراتر از اشكال طولاني خود پياده سازي مي شوند. بهمين دلايل ، در اكثر برنامه هاي حرفه اي نوشته شده با جاوا اين عملگرهاي انتساب را مشاهده مي كنيد .
در زير برنامه اي وجود دارد كه چندين عملگر انتساب op را نشان مي دهد :

+ // Demonstrate several assignment operators.
+ class OpEquals {
+ public static void main(String args[] ){
+ int a = 1;
+ int b = 2;
+ int c = 3;
+
+ a += 5;
+ b *= 4;
+ c += a * b;
+ c %= 6;
+ System.out.println("a = " + a);
+ System.out.println("b = " + b);
+ System.out.println("c = " + c);
+ }
+ }

خروجي اين برنامه بقرار زير مي باشد :

a=6
b=8
c=3


افزايش و كاهش Increment and Decrement
علامات ++ و -- عملگرهاي افزايشي و كاهشي جاوا هستند . اين عملگرها را قبلا" معرفي كرده ايم . در اينجا آنها را با دقت بيشتري بررسي مي كنيم . همانگونه كه خواهيد ديد ، اين عملگرها خصلتهاي ويژه اي دارند كه بسيار جالب توجه است . بحث درباره اين عملگرها را از نحوه كار آنها شروع مي كنيم .

عملگر افزايشي ، عملوند خود را يك واحد افزايش مي دهد . عملگر كاهشي نيز عملوند خود را يك واحد كاهش مي دهد .

بعنوان مثال ، دستور زير را

+ x = x + 1;

مي توان با استفاده از عملگر افزايشي بصورت زير دوباره نويسي نمود :
+ x++;

بطور مشابهي ، دستور زير را
+ x = x - 1;

مي توان بصورت زير باز نويسي نمود :
+ x--;

اين عملگرها از آن جهت كه هم بشكل پسوند جايي كه بعد از عملوند قرار مي گيرند و هم بشكل پيشوند جايي كه قبل از عملوند قرار مي گيرند ظاهر مي شوند كاملا" منحصر بفرد هستند. در مثالهاي بعدي هيچ تفاوتي بين اشكال پسوندي و پيشوندي وجود ندارد . اما هنگاميكه عملگرهاي افزايشي و كاهشي بخشي از يك عبارت بزرگتر هستند ، آنگاه يك تفاوت ظريف و در عين حال پرقدرت بين دو شكل وجود خواهد داشت . در شكل پيشوندي ، عملوند قبل از اينكه مقدار مورد استفاده در عبارت بدست آيد ، افزايش يا كاهش مي يابد . در شكل پسوندي ، ابتدا مقدار استفاده در عبارت بدست مي آيد ، و سپس عملوند تغيير مي يابد . بعنوان مثال :

+ x = 42;
+ y = ++x;

در اين حالت ، همانطوريكه انتظار داريد y معادل 43 مي شود ، چون افزايش قبل از اينكه xبه y منتسب شود ، اتفاق مي افتد . بدين ترتيب خط y=++ معادل دو دستور زير است :

+ x = x + 1;
+ y = x;

اما وقتي كه بصورت زير نوشته مي شوند :

+ x = 42;
+ y = x++;

مقدار x قبل از اينكه عملگر افزايشي اجرا شود ، بدست مي آيد ، بنابراين مقدار y معادل 42 مي شود . البته در هر دو حالت x معادل 43 قرار مي گيرد . در در اينجا ، خط y=x++ معادل دو دستور زير است :

+ y = x;
+ x = x + 1;



برنامه بعدي نشان دهنده عملگر افزايشي است .

+ // Demonstrate ++.
+ class IncDec {
+ public static void main(String args[] ){
+ int a = 1;
+ int b = 2;
+ int c;
+ int d;
+
+ c = ++b;
+ d = a++;
+ c++;
+ System.out.println("a = " + a);
+ System.out.println("b = " + b);
+ System.out.println("c = " + c);
+ System.out.println("d = " + d);
+ }
+ }



خروجي اين برنامه بقرار زير مي باشد :

a=2
b=3
c=4
d=1

عملگرهاي رفتار بيتي The Bitwise operators
جاوا چندين عملگر رفتار بيتي تعريف نموده كه قابل اعمال روي انواع عدد صحيح شامل long، int،، short،، char،و byteو مي باشند . اين عملگرها روي بيت هاي تكي عملوندهاي خود عمل مي كنند . اين عملگرها را در جدول زير خلاصه نموده ايم :

نتيجه آن عملگر

Bitwise unary Not
Not يكاني رفتار بيتي ~ Bitwise AND
AND رفتار بيتي & Bitwise OR
OR رفتار بيتي | Bitwise exclusive OR
OR خارج رفتار بيتي ^ shift right
>> حركت براست shift right zero fill
>>> حركت براست پر شده با صفر shift left
<< حركت به چپ Bitwise AND assignment
انتساب AND رفتار بيتي &= Bitwise OR assignment
انتساب OR رفتار بيتي |= Bitwise exclusive OR assignment
انتساب OR خارج رفتار بيتي ^= shift right assignment
انتساب حركت راست = >>shift right zero fill assignment
انتساب حركت براست پر شده با صفر = >>>shift left assignment
انتساب حركت به چپ = <<

از آنجاييكه عملگرهاي رفتار بيتي با بيت هاي داخل يك عدد صحيح سر و كار دارند ، بسيار مهم است بدانيم كه اين سر و كار داشتن چه تاثيري ممكن است روي يك مقدار داشته باشد . بخصوص بسيار سودمند است بدانيم كه جاوا چگونه مقادير عدد صحيح را ذخيره نموده و چگونه اعداد منفي را معرفي مي كند . بنابراين ، قبل از ادامه بحث ، بهتر است اين دو موضوع را باختصار بررسي نماييم .

كليه انواع صحيح بوسيله ارقام دودوئي ( باينري ) داراي پهناي بيتي گوناگون معرفي ميشوند. بعنوان مثال ، مقدار byte عدد 42 در سيستم باينري معادل 00101010 است ، كه هر يك از اين نشانه ها يك توان دو را نشان مي دهند كه با 2 به توان 0 در بيت سمت راست شروع شده است . يا موقعيت بعدي بيت بطرف چپ 2'يا 2ا است و به طرف چپ بيت بعدي 2 به توان 2يا 4ا است ، بعدي 8 ، 16 ، 32 و همينطور الي آخر هستند . بنابراين عدد 42 بيت 1 را در موقعيتهاي اول ، سوم و پنجم ( از سمت راست درنظربگيريد ) دارد. بدين ترتيب 42 معادل جمع 5 بتوان 3+2 بتوان 1+2 بتوان 2 يعني 2+8+32 مي باشد .

كليه انواع عدد صحيح ( باستثنائ char ) اعداد صحيح علامت دار هستند . يعني كه اين انواع مقادير منفي را همچون مقادير مثبت مي توانند معرفي كنند . جاوا از يك روش رمزبندي موسوم به مكمل دو (two's omplement) استفاده مي كند كه در آن ارقام منفي با تبديل ( تغيير 1به 0 و بالعكس ) كليه بيت هاي يك مقدار و سپس اضافه نمودن 1 به آن معرفي مي شوند . بعنوان مثال براي معرفي 42 ، ابتدا كليه بيت هاي عدد 42 (00101010) را تبديل مي نماييم كه 11010101 حاصل مي شود آنگاه 1 را به آن اضافه مي كنيم . كه حاصل نهايي يعني 11010110 معرف عدد 42 خواهد بود . براي رمز گشايي يك عدد منفي ، كافي است ابتدا كليه بيت هاي آن را
تبديل نموده ، آنگاه 1 را به آن اضافه نماييم . 42- يعني 11010110 پس از تبديل برابر 00101001 يا 41 شده و پس از اضافه نمودن 1 به آن برابر 42 خواهد شد .

دليل اينكه جاوا( واكثر زبانهاي برنامه نويسي )از روش مكمل دو(two's complement) استفاده مي كنند ، مسئله تقاطع صفرها (Zero crossing) است . فرض كنيد يك مقدار byteبراي صفر با 00000000 معرفي شده باشد. در روش مكمل يك (one's complement) تبديل ساده كليه بيت ها منجر به 11111111 شده كه صفر منفي را توليد مي كند .

اما مشكل اين است كه صفر منفي در رياضيات عدد صحيح غير معتبر است . اين مشكل بااستفاده از روش مكمل دو (two's complement) براي معرفي مقادير منفي حل خواهد شد . هنگام استفاده از روش مكمل دو ، 1 به مكمل اضافه شده و عدد 100000000 توليد مي شود . اين روش بيت 1 را در منتهي اليه سمت چپ مقدار byte قرار داده تا رفتار مورد نظر انجام گيرد، جايي كه 0با 0ا يكسان بوده و 11111111 رمزبندي شده 1 است . اگر چه در اين مثال از يك مقدار byte استفاده كرديم ، اما همين اصول براي كليه انواع عدد صحيح جاوا صدق مي كنند .
از آنجاييكه جاوا از روش مكمل دو براي ذخيره سازي ارقام منفي استفاده ميكند و چون كليه اعداد صحيح در جاوا مقادير علامت دار هستند بكار بردن عملگرهاي رفتار بيتي براحتي نتايج غير منتظره اي توليد مي كند . بعنوان مثال برگرداندن بيت بالاتر از حد مجاز (high-order) سبب مي شود تا مقدار حاصله بعنوان يك رقم منفي تفسير شود ، خواه چنين قصدي داشته باشيد يا نداشته باشيد . براي جلوگيري از موارد ناخواسته ، فقط بياد آوريد كه بيت بالاتر از حد مجاز (high-order) علامت يك عدد صحيح را تعيين مي كند، صرفنظر از اينكه بيت فوق چگونه مقدار گرفته
باشد .

عملگرهاي منطقي رفتار بيتي
عملگرهاي منطقي رفتار بيتي شامل &، |،، ^،، ~، هستند. جدول زير حاصل هر يك از اين عمليات را نشان مي دهد . در بحث بعدي بياد داشته باشيد كه عملگرهاي رفتار بيتي به بيت هاي منفرد داخل هر عملوند اعمال مي شوند .

A B A|B A&B A^B ~A
0 0 0 0 0 1
1 0 1 0 1 0
0 1 1 0 1 1
1 1 1 1 0 0

NOT


رفتار بيتي
عملگر NOT يكاني يعني ~ كه آن را مكمل رفتار بيتي (bitwise complement) هم مي نامند ، كليه بيت هاي عملوند خود را تبديل مي كند . بعنوان مثال ، عدد 42 كه مطابق الگوي بيتي زير است : 00101010

پس از اعمال عملگر NOT بصورت زير تبديل مي شود : 11010101

AND

رفتار بيتي

عملگر AND يعني & اگر هر دو عملوند 1 باشند ، يك بيت 1 توليد مي كند . در كليه شرايط ديگر يك صفر توليد مي شود . مثال زير را نگاه كنيد :

00101010 42

& 00001111 15

00001010 10

OR

رفتار بيتي

عملگر OR يعني | بيت ها را بگونه اي تركيب مي كند كه اگر هر يك از بيت هاي عملوندها 1 باشد ، آنگاه بيت حاصله نيز 1 خواهد بود . به مثال زير نگاه كنيد :

00102010 42

| 00001111 15

00101111 47

XOR

رفتار بيتي

عملگر XOR يعني ^ بيت ها را بگونه اي تركيب مي كند كه اگر دقيقا" يك عملوند 1باشد ، حاصل برابر 1 خواهد شد . در غير اينصورت ، حاصل 0 مي شود .

مثال بعدي چگونگي كار اين عملگر را نشان مي دهد . اين مثال همچنين يكي از خصلتهاي سودمند عملگر XOR را نمايش مي دهد . دقت كنيد كه هر جا عملوند دوم يك بيت 1 داشته باشد ، چگونه الگوي بيتي عدد 42 تبديل مي شود . هر جا كه عملوند دوم بيت 0 داشته باشد ، عملوند اول بدون تغيير مي ماند . هنگام انجام برخي از
انواع عملكردهاي بيتي ، اين خصلت بسيار سودمند است .

00101010 42

^ 00001111 15

00100101 37

استفاده از عملگرهاي منطقي رفتار بيتي

برنامه بعدي نشان دهنده عملگرهاي منطقي رفتار بيتي است :

+ // Demonstrate the bitwise logical operators.
+ class BitLogic {
+ public static void main(String args[] ){
+ String binary[] = {
+ "0000"/ "0001"/ "0010"/ "0011"/ "0100"/ "0101"/ "0110"/ "0111"/
+ "1000"/ "1001"/ "1010"/ "1011"/ "1100"/ "1101"/ "1110"/ "1111"
+ };
+ int a = 3; // 0 + 2 + 1 or 0011 in binary
+ int b = 6; // 4 + 2 + 0 or 0110 in binary
+ int c = a | b;
+ int d = a & b;
+ int e = a ^ b;
+ int f =( ~a & b )|( a & ~b);
+ int g = ~a & 0x0f;
+
+ System.out.println(" a = " + binary[a]);
+ System.out.println(" b = " + binary[b]);
+ System.out.println(" a|b = " + binary[c]);
+ System.out.println(" a&b = " + binary[d]);
+ System.out.println(" a^b = " + binary[e]);
+ System.out.println("~a&b|a&~b = " + binary[f]);
+ System.out.println(" ~a = " + binary[g]);
+ }
+ }



در اين مثال ، aو bو الگوهاي بيتي دارند كه كليه چهار احتمال براي ارقام دو تايي باينري را معرفي مي كنند . 0-0، 0-1،، 1-0،و 1-1و . مي توانيد مشاهده كنيد چگونه |و &و روي هر يك از بيت ها با توجه به نتايج در cو dو عمل مي كنند.

مقادير نسبت داده شده به eو fو مشابه بوده و نشان دهنده چگونگي كار عملگر ^ مي باشند . آرايه رشته اي با نام binary معرفي ارقام 0 تا 15 را بصورت باينري و قابل خواندن براي انسان نگهداري مي كند . در اين مثال ، آرايه فوق طوري نمايه سازي شده تا معرفي باينري هر يك از نتايج را نشان دهد . آرايه طوري ساخته شده كه معرفي رشته اي صحيح يك مقدار باينري n را در binary[n] ذخيره مي كند . مقدار ~aبوسيله عملگر ANDبا oxofا( 00001111 باينري ) عمل شده تا مقدار آن را به كمتر از 16 كاهش دهد تا بتوان با استفاده از آرايه binary از آن چاپ گرفت .

اكنون خروجي اين برنامه بصورت زير مي باشد :

a=1011
b=0110
a^Eb=0111
a&b=0010
a&b=0101
~a&b^Ea&~b=0101
~a=1100


حركت به چپ
كليه بيت هاي موجود در يك مقدار را به تعداد <<عملگر حركت به چپ يعني دفعات مشخص بطرف چپ منتقل مي كند . شكل كلي آن بقرار زير است :

Value << num

تعداد دفعات مقدار
در ايجا num مشخص كننده تعداد مكانهايي است كه بيت هاي موجود در value بايد كليه بيت هاي موجود در يك مقدار مشخص را <<به چپ انتقال يابند . بدين ترتيب بتعداد مكانهايي كه در num مشخص شده بطرف چپ حركت مي دهد . براي هر بار حركت به چپ ، بيت high-order ( بيش از حد مجاز ) منتقل شده و از دست خواهد رفت و يك صفر در طرف راست مقدار ، جايگزين مي شود . بدين ترتيب هنگاميكه يك حركت به چپ روي يك عملوند int عمل مي كند ، بيت هاي گذشته از مكان 31 از دست خواهند رفت . اگر عملوند يك long باشد، بيت ها پس از گذشتن از مكان 63 از دست ميروند.

هنگاميكه مقادير byteو shortو را انتقال مي دهيد ، ارتقائ خودكار انواع در جاوا نتايج غير منتظره اي ايجاد مي كند . حتما" مي دانيد كه هنگام ارزشيابي عبارات ، مقادير byteو shortوبه int ارتقائ مي يابند. بعلاوه جواب چنين عبارتي از نوع int خواهد بود . بنابراين حاصل يك حركت به چپ روي مقادير byteو shortو يك int خواهد بود و بيت هاي انتقال يافته به چپ تا زمانيكه از مكان بيت 31 نگذرند ، از دست نمي روند . علاوه براين ، يك مقدار منفي byteو shortو هنگاميكه به int ارتقائ مي يابد ، بسط علامت پيدا مي كند . بنابراين بيت هاي بيش از حد
مجاز با بيت 1 پر مي شوند . بخاطر اين دلايل ، انجام يك حركت به چپ روي byte و short مستلزم آن است كه از بايت هاي بيش از حد مجاز در جواب int دست بكشيد .

بعنوان مثال ، اگر يك مقدار byte را حركت به چپ بدهيد ، آن مقدار ابتدا به نوع intتبديل شده و سپس انتقال خواهد يافت . بايد سه بايت بالايي حاصل را از دست بدهيد . اگر بخواهيد حاصل يك مقدار byte انتقال يافته را بدست آوريد . بايد سه بايت بالايي حاصل را از دست بدهيد . آسان ترين روش براي انجام اينكار استفاده
از تبديل cast و تبديل جواب به نوع byte است . مثال بعدي همين مفهوم را براي شما آشكار مي سازد :

+ // Left shifting a byte value.
+ class ByteShift {
+ public static void main(String args[] ){
+ byte a = 64/ b;
+ int i;
+
+ i = a << 2;
+ b =( byte( )a << 2);
+
+ System.out.println("Original value of a :" + a);
+ System.out.println("i and b :" + i + " " + b);
+ }
+ }

خروجي توليد شده توسط اين برنامه بقرار زير مي باشد :

original value of a:64
i and b :256 0

چون براي اهداف ارزشيابي ، a به نوع int ارتقائ يافته ، دوبار حركت به چپ مقدار 64 (0000 َ0100) منجر به i مي گردد كه شامل مقدار 256 (0000 َ1 0000) مي باشد . اما مقدار b دربرگيرنده صفر است زيرا پس از انتقال ، بايت كمتر از حد مجاز (loworder) اكنون شامل صفر است . تنها بيت دربرگيرنده 1 به بيرون انتقال يافته است .
از آنجاييكه هر بار حركت به چپ تاثير دو برابر سازي مقدار اصلي را دارد برنامه نويسان اغلب از اين خاصيت بجاي دو برابر كردن استفاده مي كنند . اما بايد مراقب باشيد . اگر يك بيت 1 را به مكان بيت بيش از حد مجاز (31 يا 63)
منتقل كنيد ، مقدار فوق منفي خواهد شد . برنامه بعدي همين نكته را نشان ميدهد.

+ // Left shifting as a quick way to multiply by 2.
+ class MultByTwo {
+ public static void main(String args[] ){
+ int i;
+ int num = 0xFFFFFFE;
+
+ for(i=0; i<4; i++ ){
+ num = num << 1;
+ System.out.println(num);
+ }
+ }
+ }

خروجي اين برنامه بقرار زير خواهد بود : 536870908

1073741816
2147483632
- 32

مقدار آغازين را با دقت انتخاب كرده ايم بطوريكه بيت بعد از چهار مكان حركت بطرف چپ ، مقدار 32- را توليد نمايد . همانطوريكه مي بينيد ، هنگاميكه بيت 1 به بيت 31 منتقل مي شود ، رقم بعنوان منفي تفسير خواهد شد .

حركت به راست
كليه بيت هاي موجود در يك مقدار را به تعداد >>عملگر حركت به راست يعني دفعات مشخص بطرف راست انتقال مي دهد . شكل كلي آن بقرار زير مي باشد :

value >> num

تعداد دفعات مقدار
در اينجا ، num مشخص كننده تعداد مكانهايي است كه بيت هاي value بايد بطرف كليه بيت هاي يك مقدار مشخص شده را به تعداد >>راست انتقال يابند . يعني مكانهاي بيتي مشخص شده توسط num بطرف راست انتقال مي دهد .

كد قطعه اي زير مقدار 32 را دو مكان بطرف راست منتقل مي كند و آنگاه جواب آن در a معادل 8 قرار مي گيرد :

+ int a = 32;
+ a = a >> 2; // a now contains 8

اگر بيت هايي از يك مقدار به بيرون منتقل شوند ، آن بيت ها از دست خواهند رفت . بعنوان مثال كد قطعه اي بعدي مقدار 35 را دو مكان بطرف راست منتقل نموده و باعث مي شود تا دو بيت كمتر از حد مجاز از دست رفته و مجددا" جواب آن در a معادل 8 قرار گيرد .

+ int a = 35;
+ a = a >> 2; // a still contains 8

همين عمليات را در شكل باينري نگاه مي كنيم تا اتفاقي كه مي افتد ، روشن تر شود : 00100011 35
>> 2
00001000 8

هر بار كه يك مقدار را به طرف راست منتقل مي كنيد ، آن مقدار تقسيم بر دو مي شود و باقيمانده آن از دست خواهد رفت . مي توانيد از مزاياي اين روش در تقسيم بر دو اعداد صحيح با عملكرد سطح بالا استفاده نماييد . البته ، بايد مطمئن شويد كه بيت هاي انتهايي سمت راست را به بيرون منتقل نكنيد .

هنگاميكه حركت بطرف راست را انجام مي دهيد ، بيت هاي بالايي ( از سمت چپ ) در معرض حركت بطرف راست قرار گرفته ، با محتوي قبلي بيت بالايي پر مي شوند .

اين حالت را بسط علامت (sign extension) ناميده و براي محفوظ نگهداشتن علامت ارقام منفي هنگام حركت بطرف راست استفاده مي شوند. بعنوان مثال 1>>8- معادل 4- است كه به شكل باينري زير مي باشد :

11111000- 8
>> 1
11111100- 4

جالب است بدانيد كه اگر 1- را بطرف راست حركت دهيد، حاصل آن همواره 1- باقي مي ماند ، چون بسط علامت ، مراقب آوردن يك بيت ديگر در بيت هاي بيش از حد مجاز خواهد بود .

گاهي هنگام حركت بطرف راست مقادير ، مايل نيستيم تا بسط علامت اجرا شود .

بعنوان مثال ، برنامه بعدي يك مقدار نوع byte را به معرفي رشته اي در مبناي 16 تبديل مي كند . دقت كنيد كه مقدار منتقل شده با استفاده از عملگر ANDيا oxofا پوشانده شده تا هر گونه بيت هاي بسط يافته علامت را بدور اندازد بطوريكه مقدار فوق را بتوان بعنوان يك نمايه به آرايه اي از كاراكترهاي در مبناي 16 استفاده نمود .

+ // Masking sign extension.
+ class HexByte {
+ static public void main(String args[] ){
+ char hex[] = {
+ '0'/ '1'/ '2'/ '3'/ '4'/ '5'/ '6'/ '7'/
+ '8'/ '9'/ 'a'/ 'b'/ 'c'/ 'd'/ 'e'/ 'f'
+ };
+ byte b =( byte )oxf1
+
+ System.out.println("b = ox" + hex[(b >> 4 )& oxof] + hex[b & oxof]);
+ }
+ }

خروجي اين برنامه بقرار زير مي باشد :
b=oxf1

حركت به راست فاقد علامت
بطور خودكار >>اكنون مي دانيد كه هر بار يك انتقال اتفاق مي افتد ، عملگر جاي خالي بيت بيش از حد مجاز را با محتوي قبلي اش پر مي كند . اين عمل سبب حفظ علامت آن مقدار مي گردد . اما گاهي تمايلي براي اينكار نداريم . بعنوان مثال مي خواهيد چيزي را منتقل كنيد كه معرف يك مقدار عددي نيست . بالطبع نمي خواهيد
عمل بسط علامت انجام گيرد . اين حالت هنگام كار با مقادير براساس پيكسل (pixel) و گرافيك اغلب وجود دارد . در چنين شرايطي لازم است تا مقدار صفر در بيت بيش از حد مجاز قرار گيرد ، صرفنظر از اينكه مقدار قبلي در آن بيت چه بوده است . اين حالت را انتقال فاقد علامت (usigned shift) مي گويند. براي اين منظور، از عملگر
استفاده كنيد كه صفرها را در بيت بيش >>>حركت به راست فاقد علامت در جاوا يعني از حد مجاز منتقل مي كند .

مي باشد . در اينجا >>>كد قطعه اي زير نشان دهنده عملگر a معادل 1- است كه كليه 32 بيت را در باينري روي 1 تنظيم مي كند . اين مقدار سپس 24 بيت بطرف راست انتقال مي يابد، و 24 بيت بالايي را با صفرها پر مي كند و بسط علامت معمولي را ناديده مي گيرد . بدين ترتيب a معادل 255 مي باشد .

+ int a =- 1;
+ a = a >>> 24;

اينجا همان عمليات را در شكل باينري مشاهده مي كنيد تا بهتر بفهميد چه اتفاقي افتاده است : 1
در باينري بعنوان يك int 11111111 11111111 11111111 11111111 >>>24
255
در باينري بعنوان يك int َ11111111 00000000 00000000 00000000 اغلب اوقات آنچنان سودمند كه بنظر مي رسد ، نبوده چون فقط براي >>>عملگر مقادير 32 بيتي و 64 بيتي معني دارد . بياد آوريد كه مقادير كوچكتر در عبارات بطور خودكار به int ارتقائ مي يابند . بدين ترتيب بسط علامت اتفاق افتاده و حركت بجاي مقادير 8 بيتي و 16 بيتي روي مقادير 32 بيتي انجام مي شود . يعني بايد انتظار يك حركت به راست فاقد علامت روي يك مقدار byte داشته باشيم كه در بيت 7 ، صفر را قرار مي دهد . اما واقعا" اينطور نيست ، چون در واقع مقدار 32
بيتي است كه منتقل مي شود . برنامه بعدي اين تاثيري را نشان مي دهد .

+ // Unsigned shifting a byte value.
+ class ByteUShift {
+ static public void main(String args[] ){
+ char hex[] = {
+ '0'/ '1'/ '2'/ '3'/ '4'/ '5'/ '6'/ '7'/
+ '8'/ '9'/ 'a'/ 'b'/ 'c'/ 'd'/ 'e'/ 'f'
+ };
+ byte b =( byte )oxf1
+ byte c =( byte( )b >> 4);
+ byte d =( byte( )b >>> 4);
+ byte e =( byte(( )b & oxff )>> 4);
+
+ System.out.println(" b = ox"
+ + hex[(b >> 4 )& oxof] + hex[b & oxof]);
+ System.out.println(" b >> 4 = ox"
+ + hex[(c >> 4 )& oxof] + hex[c & oxof]);
+ System.out.println(" b >>> 4 = ox"
+ + hex[(d >> 4 )& oxof] + hex[d & oxof]);
+ System.out.println("(b & oxof )>> 4 = ox"
+ + hex[(e >> 4 )& oxof] + hex[e & oxof]);
+ }
+ }

چگونه هنگام كار با بايت ها عملي >>>خروجي اين برنامه نشان ميدهد كه عملگر انجام نمي دهد . متغير b بعنوان يك مقدار byte منفي قراردادي در اين نمايش تنظيم شده است . سپس مقدار byteدر bر كه چهار مكان بطرف راست انتقال بافته به C منتسب مي شود كه بخاطر بسط علامت مورد انتظار oxff است . سپس مقدار byteدر bر كه چهار مكان بطرف راست و فاقد علامت منتقل شده به d منتسب مي شود كه انتظار داريد oxof باشد ، اما در حقيقت oxff است چون بسط علامت هنگاميكه b به نوع int قبل از انتقال ارتقائ يافته اتفاق افتاده است . آخرين عبارت ، e را در مقدار byte متغير b كه با استفاده از عملگر ANDبا 8ا بيت پوشانده شده تنظيم نموده و سپس چهار مكان بطرف راست منتقل مي كند كه مقدار مورد انتظار oxof را توليد مي كند . دقت كنيد كه عملگر حركت به راست فاقد علامت براي d استفاده نشد ، چون حالت بيت علامت بعد از AND شناخته شده است .

b=oxf1
b>>4=oxff
b>>>4=oxff
( b&oxff)>>4=oxof

انتسابهاي عملگر رفتار بيتي

كليه عملگرهاي رفتار بيتي باينري يك شكل مختصر مشابه باعملگرهاي جبري دارند كه عمل انتساب را با عمليات رفتار بيتي تركيب مي كنند. بعنوان مثال ، دو دستور بعدي كه مقدار a را چهار بيت به راست حركت مي دهند ، معادل يكديگرند :

+ a = a >> 4;
+ a >>= 4;

بطور مشابه ، دو دستور زير كه a را به عبارت روش بيتي aoRb منتسب مي كنند معادل يكديگرند :

+ a = a | b;
+ a |= b;

برنامه بعدي تعدادي از متغيرهاي عدد صحيح را بوجود آورده آنگاه از شكل مختصر انتسابهاي عملگر رفتار بيتي براي كار كردن بااين متغيرها استفاده ميكند:

+ class OpBitEquals {
+ public static void main(String args[] ){
+ int a = 1;
+ int b = 2;