Java Operators ( 4 ‍ව‍න ‍කො‍ට‍ස )

Java  Operators ( 4 ‍ව‍න ‍කො‍ට‍ස )

අපි අද කතා කරන්න යන්නෙ java වල එන bitwise operators ගැන.

operator	meaning
&	Bitiwise AND
|	Bitwise  OR
^	Bitwise XOR
>>	Right shift
<<	Left shift
>>>	Zero fill right shift
~	Bitwise compliment

මෙම operators  ගැන වැඩි දුර කතා කිරීමට පෙර decimal සංඛයාවක්(10 පාදයේ සංඛයාවක්)  binary  සංඛයාවක්(2 පාදයේ සංඛයාවක් )  කරන අකාරය සලකා බලමු. ඒ සදහා අදාල decimal  සංඛයාව ලබ්දිය 0  වන තෙක්  දිගටම 2න් බෙදා ගෙන යන්න.  අවසානයේ අග සිට මුලට ශේෂයන් ලබා ගන්න. එවිට අදාල binary  සංඛයාව ලැබේ.

Ex:  27 binary  සංඛයාවක් කරන ආකරය බලමු.


                          ලබ්දිය                    ශේෂය

27/2                      13                         1

13/2                      6                           1                

6/2                        3                           0

3/2                        1                           1

1/2                        0                           1             

(ලබ්දිය 0 වන තෙක් බෙදා පහල සිට ඉහලට ශේශයන් ලබා ගන්න.එවිට 27 ට අදාල binary  සංඛයාව 11011  ලෙස  ලැබේ.  )

Bitiwise AND(&)  භාවිතය :

Input1	Input2	Output (input1  &   input2 )
1	1	1
1	0	0
0	1	0
0	0	0

මම මෙය උදාහරනයක් මගින් පැහැදිලි කරන්නම්.

4 & 5   සලකමු.  මෙහිදී 4 සහ 5  binary  සංඛයා බවට පරිවර්තනය කොට ගෙන එම සංඛයා වලට  &  operator එක යෙදිම සිදුවේ.

4  binary වලින් ලියූ විට                          1    0        0

5  binary වලින් ලියූ විට                          1    0        1

දැන්       100    &  101 සිදුවී පිලිතුර ලෙස 100 ලැබේ.. මෙය සිදු වන ආකරය පහත දැක්වේ.

         

          1                      &                         1             =       1

          0                      &                         0             =       0

          0                      &                         1             =       0

                                 

එනම් 4&5=4  ලෙස ලැබේ.

Bitiwise  OR(|)  භාවිතය :

Input1	Input2	Output (input1  |   input2 )
1	1	1
1	0	1
0	1	1
0	0	0

මම මෙය උදාහරනයක් මගින් පැහැදිලි කරන්නම්.

4 | 5   සලකමු.  මෙහිදී 4 සහ 5  binary  සංඛයා බවට පරිවර්තනය කොට ගෙන එම සංඛයා වලට  |  operator එක යෙදිම සිදුවේ.

4  binary වලින් ලියූ විට                          1    0        0

5  binary වලින් ලියූ විට                          1    0        1

දැන්       100   |  101 සිදුවී පිලිතුර ලෙස 101 ලැබේ.. මෙය සිදු වන ආකරය පහත දැක්වේ.

         

          1                      |                           1             =       1

          0                      |                           0             =       0

          0                      |                           1             =       1

                                                                   

එනම් 4|5=5 ලෙස ලැබේ.

Bitiwise  X OR(^)  භාවිතය :

Input1	Input2	Output (input1  ^  input2 )
1	1	0
1	0	1
0	1	1
0	0	0

මම මෙය උදාහරනයක් මගින් පැහැදිලි කරන්නම්.

4 ^ 5   සලකමු.  මෙහිදී 4 සහ 5  binary  සංඛයා බවට පරිවර්තනය කොට ගෙන එම සංඛයා වලට  ^  operator එක යෙදිම සිදුවේ.

4  binary වලින් ලියූ විට                          1    0        0

5  binary වලින් ලියූ විට                          1    0        1

දැන්       100    ^  101 සිදුවී පිලිතුර ලෙස 001 ලැබේ.. මෙය සිදු වන ආකරය පහත දැක්වේ.

         

          1                      |                           1             =       0

          0                      |                           0             =       0

          0                      |                           1             =       1

                                                                   

එනම් 4 ^5=1 ලෙස ලැබේ.

Left  shift(<<)

Int b=5;

b <<2 සලකමු.මෙහිදි 5   binary වලට හරවා ගෙන එය ස්ථාන 2 කින්  වමට තල්ලු (shift)කරයි. මෙහිදී  දකුනු පස ඇති වන  හිස් ස්ථාන 0 සංකේතයෙන් පුරවනු ලබයි.

5  binary වලින් ලියූ විට                         00000000000000000000000000000101

(මෙහිදී 5 int එකක් ලෙස සලක ඇති නිසා binary සංඛයාව ඉලක්කම් 32 කින් ලියා ඇත.)

5<<2                                                   00000000000000000000000000010100

එනම් 5<<2= 20 ලෙස ලැබේ.

Right   shift(>>)

Int b=5;

b>>2 සලකමු.මෙහිදි 5   binary වලට හරවා ගෙන එය ස්ථාන 2 කින්   දකුනට තල්ලු (shift)කරයි. මෙහිදී  වම් පස ඇති වන  හිස් ස්ථාන 0 සංකේතයෙන් පුරවනු ලබයි.

5  binary වලින් ලියූ විට                        00000000000000000000000000000101

(මෙහිදී 5 int එකක් ලෙස සලක ඇති නිසා binary සංඛයාව ඉලක්කම් 32 කින් ලියා ඇත.)

5>>2                                                   00000000000000000000000000000001

එනම් 5>>2= 1ලෙස ලැබේ.

Zero fill right shift(>>>)

ඔබ -  සංඛයාවක් right shift කරයි  නම් මෙම  සංකේතය(>>>) භාවිතා කල යුතුයි. එනම් -5 ස්ථාන 2 කින්  right shift කල යුතු නම් -5>>>2  ලෙස දැක් විය යුතුය.

Bitwise compliment(~)

යම්  binary සංඛයාවක  ඇති  0 ද්වීමය 1 කිරීමටත් 1 ද්වීමය 0 කිරීමටත්   ~  operator  එක යොදා ගනී.

   a=17=10001

~a=01110

අපි මෙතෙක් උගත් operators ගැන වැඩිදුර තහවුරු කර ගැනීමට  පහත  programme  එක  run කර බලන්න.

public class BitWiseOperators{
 public static void main(String args[]){
  int a=4 ,b=5 ,c=-5;
  int d=a&b;
  int  e=a|b;
  int  f=a^b;
  int  g= a<<2;
  int h=a>>2;
  int i=c>>>2;
  int j=~a;
  System.out.println("4 & 5   ="+d );
  System.out.println("4 | 5   ="+e );
  System.out.println("4 ^ 5   ="+f );
  System.out.println("4 << 2  ="+ g );
  System.out.println("4 >> 2  ="+ h );
  System.out.println("-5>>> 2 ="+i);
  System.out.println("~4      ="+ j);
 }
}

මෙහි output එක :

ලගදිම තවත්  පඩමකින් හමුවෙමු…………