Java的位運算符詳解實例——與（&）、非（~）、或（|）、異或（^）

轉自：http://blog.csdn.net/is_zhoufeng/article/details/8112199

自己保留，遇到的再補全

位運算符主要針對二進制，它包括了：“與”、“非”、“或”、“異或”。從表面上看似乎有點像邏輯運算符，但邏輯運算符是針對兩個關係運算符來進行邏輯運算，而位運算符主要針對兩個二進制數的位進行邏輯運算。下面詳細介紹每個位運算符。

 

1．與運算符
與運算符用符號“&”表示，其使用規律如下：
兩個操作數中位都爲1，結果才爲1，否則結果爲0，例如下面的程序段。
public class data13
{
public static void main(String[] args)
{
int a=129;
int b=128;
System.out.println("a 和b 與的結果是："+(a&b));
}
}
運行結果
a 和b 與的結果是：128
下面分析這個程序：
“a”的值是129，轉換成二進制就是10000001，而“b”的值是128，轉換成二進制就是10000000。根據與運算符的運算規律，只有兩個位都是1，結果纔是1，可以知道結果就是10000000，即128。

 

2．或運算符
或運算符用符號“|”表示，其運算規律如下：
兩個位只要有一個爲1，那麼結果就是1，否則就爲0，下面看一個簡單的例子。
public class data14
{
public static void main(String[] args)
{
int a=129;
int b=128;
System.out.println("a 和b 或的結果是："+(a|b));
}
}
運行結果
a 和b 或的結果是：129
下面分析這個程序段：
a 的值是129，轉換成二進制就是10000001，而b 的值是128，轉換成二進制就是10000000，根據或運算符的運算規律，只有兩個位有一個是1，結果纔是1，可以知道結果就是10000001，即129。

 

3．非運算符
非運算符用符號“~”表示，其運算規律如下：

如果位爲0，結果是1，如果位爲1，結果是0，下面看一個簡單例子。
public class data15
{
public static void main(String[] args)
{
int a=2;
System.out.println("a 非的結果是："+(~a));
}
}

 

4．異或運算符
異或運算符是用符號“^”表示的，其運算規律是：
兩個操作數的位中，相同則結果爲0，不同則結果爲1。下面看一個簡單的例子。
public class data16
{
public static void main(String[] args)
{
int a=15;
int b=2;
System.out.println("a 與 b 異或的結果是："+(a^b));
}
}
運行結果
a 與 b 異或的結果是：13
分析上面的程序段：a 的值是15，轉換成二進制爲1111，而b 的值是2，轉換成二進制爲0010，根據異或的運算規律，可以得出其結果爲1101 即13。

Java中的運算符（操作符）

    程序的基本功能是處理數據，任何編程語言都有自己的運算符。因爲有了運算符，程序員才寫出表達式，實現各種運算操作，實現各種邏輯要求。

   爲實現邏輯和運算要求，編程語言設置了各種不同的運算符，且有優先級順序，所以有的初學者使用複雜表達式的時候搞不清楚。這裏詳細介紹一下Java中的運算符。

    Java運算符很多，下面按優先順序列出了各種運算符。

 

 

優先級	運算符分類	結合順序	運算符
由 高 到 低	分隔符	左結合	.    []     ( )     ;      ,
	一元運算符	右結合	!  ++     --     -   ~
	算術運算符 移位運算符	左結合	*     /      %    +     -      <<   >>   >>>
	關係運算符	左結合	<     >     <=   >=   instanceof(Java 特有)   = =  !=
	邏輯運算符	左結合	! &&  ||  ~  &  |  ^
	三目運算符	右結合	布爾表達式?表達式1:表達式2
	賦值運算符	右結合	=  *=     /=  %=   +=   -=    <<= >>= >>>=  &=  *=  |=

 

一、一元運算符

    因操作數是一個，故稱爲一元運算符。

運算符	含義	例子
-	改變數值的符號，取反	-x（-1*x）
~	逐位取反，屬於位運算符	~x
++	自加1	x++
--	自減1	x--

++x 因爲++在前，所以先加後用。
x++ 因爲++在後，所以先用後加。

注意：a+ ++b和a+++b是不一樣的（因爲有一個空格）。

  int a=10;
  int b=10;
  int sum=a+ ++b;
  System.out.println("a="+a+",b="+b+",sum="+sum);
運行結果是： a=10,b=11,sum=21

  int a=10;
  int b=10;
  int sum=a+++b;
  System.out.println("a="+a+",b="+b+",sum="+sum);
運行結果是：a=11,b=10,sum=20

n=10;
m=~n;
變量n的二進制數形式：                 00000000 00000000 00000000 00001010
逐位取反後，等於十進制的-11： 11111111 11111111 11111111 11110101 

二、算術運算符

    所謂算術運算符，就是數學中的加、減、乘、除等運算。因算術運算符是運算兩個操作符，故又稱爲二元運算符。

運算符	含義	例子
+	加法運算	x+y
-	減法運算	x-y
*	乘法運算	x*y
/	除法運算	x/y
%	取模運算（求餘運算）	x%y

    這些操作可以對不同類型的數字進行混合運算，爲了保證操作的精度，系統在運算過程中會做相應的轉化。數字精度的問題，我們在這裏不再討論。下圖中展示了運算過程中，數據自動向上造型的原則。

 

 

    注：1、實線箭頭表示沒有信息丟失的轉換，也就是安全性的轉換，虛線的箭頭表示有精度損失的轉化，也就是不安全的。
      2、當兩個操作數類型不相同時，操作數在運算前會子鬆向上造型成相同的類型，再進行運算。

示例如下：

 

[java] view plaincopy

1. int a=22;  
2. int b=5;  
3. double c=5;  
4.   
5. System.out.println(b+"+"+c+"="+(b+c));  
6. System.out.println(b+"-"+c+"="+(b-c));  
7. System.out.println(b+"*"+c+"="+(b*c));  
8. System.out.println(a+"/"+b+"="+(a/b));  
9. System.out.println(a+"%"+b+"="+(a%b));  
10. System.out.println(a+"/"+c+"="+(a/c));  
11. System.out.println(a+"%"+c+"="+(a%c));  

運行結果如下：

5+5.0=10.0
5-5.0=0.0
5*5.0=25.0
22/5=4
22%5=2
22/5.0=4.4
22%5.0=2.0

三、移位運算符

   移位運算符操作的對象就是二進制的位，可以單獨用移位運算符來處理int型整數。

運算符	含義	例子
<<	左移運算符，將運算符左邊的對象向左移動運算符右邊指定的位數（在低位補0）	x<<3
>>	"有符號"右移運算 符，將運算符左邊的對象向右移動運算符右邊指定的位數。使用符號擴展機制，也就是說，如果值爲正，則在高位補0，如果值爲負，則在高位補1.	x>>3
>>>	"無符號"右移運算 符，將運算符左邊的對象向右移動運算符右邊指定的位數。採用0擴展機制，也就是說，無論值的正負，都在高位補0.	x>>>3

 

 

 

以int類型的6297爲例，代碼如下：

[java] view plaincopy

1. System.out.println(Integer.toBinaryString(6297));   
2. System.out.println(Integer.toBinaryString(-6297));   
3. System.out.println(Integer.toBinaryString(6297>>5));   
4. System.out.println(Integer.toBinaryString(-6297>>5));   
5. System.out.println(Integer.toBinaryString(6297>>>5));   
6. System.out.println(Integer.toBinaryString(-6297>>>5));   
7. System.out.println(Integer.toBinaryString(6297<<5));   
8. System.out.println(Integer.toBinaryString(-6297<<5));  

 

  運行結果：

1100010011001
11111111111111111110011101100111
11000100
11111111111111111111111100111011
11000100
111111111111111111100111011
110001001100100000
11111111111111001110110011100000

注：x<<y 相當於 x*2^y ；x>>y相當於x/2^y
    從計算速度上講，移位運算要比算術運算快。
    如果x是負數，那麼x>>>3沒有什麼算術意義，只有邏輯意義。

四、關係運算符

Java具有完備的關係運算符，這些關係運算符同數學中的關係運算符是一致的。具體說明如下：

運算符	含義	例子
<	小於	x<y
>	大於	x>y
<=	小於等於	x<=y
>=	大於等於	x>=y
==	等於	x==y
!=	不等於	x!=y

instanceof操作符用於判斷一個引用類型所引用的對象是否是一個類的實例。操作符左邊的操作元是一個引用類型，右邊的操作元是一個類名或者接口，形式如下：

obj instanceof ClassName      或者    obj instanceof InterfaceName

關係運算符產生的結果都是布爾型的值，一般情況下，在邏輯與控制中會經常使用關係運算符，用於選擇控制的分支，實現邏輯要求。

需要注意的是：關係運算符中的"=="和"!="既可以操作基本數據類型，也可以操作引用數據類型。操作引用數據類型時，比較的是引用的內存地址。所以在比較非基本數據類型時，應該使用equals方法。

五、邏輯運算符

邏輯非關係值表

A	!A
true	false
false	true

 

邏輯與關係值表

A	B	A&&B
false	false	false
true	false	false
false	true	false
true	true	true

 

邏輯或關係值表

A	B	A||B
false	false	false
true	false	true
false	true	true
true	true	true

 

在運用邏輯運算符進行相關的操作，就不得不說“短路”現象。代碼如下：

if(1==1 && 1==2 && 1==3){  }

代碼從左至右執行，執行第一個邏輯表達式後：true && 1==2 && 1==3
執行第二個邏輯表達式後：true && false && 1==3
因爲其中有一個表達式的值是false，可以判定整個表達式的值是false，就沒有必要執行第三個表達式了，所以java虛擬機不執行1==3代碼，就好像被短路掉了。

邏輯或也存在“短路”現象，當執行到有一個表達式的值爲true時，整個表達式的值就爲true，後面的代碼就不執行了。
“短路”現象在多重判斷和邏輯處理中非常有用。我們經常這樣使用：

[java] view plaincopy

1. public void a(String str){  
2.   if(str!=null && str.trim().length()>0){  
3.       
4.   }  
5. }  

如果str爲null，那麼執行str.trim().length()就會報錯，短路現象保證了我們的代碼能夠正確執行。
在書寫布爾表達式時，首先處理主要條件，如果主要條件已經不滿足，其他條件也就失去了處理的意義。也提高了代碼的執行效率。

位運算是對整數的二進制位進行相關操作，詳細運算如下：

非位運算值表

A	~A
1	0
0	1

與位運算值表

A	B	A&B
1	1	1
1	0	0
0	1	0
0	0	0

或位運算值表

A	B	A | B
1	1	1
1	0	1
0	1	1
0	0	0

異或位運算值表

A	B	A&B
1	1	0
1	0	1
0	1	1
0	0	0

示例如下：

[java] view plaincopy

1. int a=15;  
2. int b=2;  
3.   
4. System.out.println(a+"&"+b+"="+(a&b));  
5. System.out.println(a+"|"+b+"="+(a|b));  
6. System.out.println(a+"^"+b+"="+(a^b));  

運算結果如下：

15&2=2
15|2=15
15^2=13

程序分析：

a	1	1	1	1	15
b	0	0	1	0	2
a&b	0	0	1	0	2
a|b	1	1	1	1	15
a^b	1	1	0	1	13

按位運算屬於計算機低級的運算，現在我們也不頻繁的進行這樣的低級運算了。

六、三目運算符

 三目運算符是一個特殊的運算符，它的語法形式如下：

布爾表達式？表達式1：表達式2

運算過程：如果布爾表達式的值爲true，就返回表達式1的值，否則返回表達式2的值，例如：

int sum=90;
String str=sum<100 ? "失敗" : "成功";

等價於下列代碼：

String str=null;
if(num<100){
  str="失敗";
}else{
  str="成功";
}

三目運算符和if……else語句相比，前者使程序代碼更加簡潔。

七、賦值運算符

賦值運算符是程序中最常用的運算符了，示例如下：

運算符	例子	含義
+=	x+=y	x=x+y
-=	x-=y	x=x-y
*=	x*=y	x=x*y
/=	x/=y	x=x/y
%=	x%=y	x=x%y
>>=	x>>=y	x=x>>y
>>>=	a>>>=y	x=x>>>y
<<=	a<<=y	x=x<<y
&=	x&=y	x=x&y
|=	x|=y	x=x|y
^=	x^=y	x=x^y

大家可以根據自己的喜好選擇合適的運算符。

補充：

字符串運算符： + 可以連接不同的字符串。

轉型運算符： （） 可以將一種類型的數據或對象，強制轉變成另一種類型。如果類型不相容，會報異常出來。

package com.zf.binary;  
  
  
public class Test1 {  
  
    public static void main(String[] args) {  
          
        /* 符號爲:最高位同時表示圖號，0爲正數，1爲負數 */  
          
        /*  
            1、二進制轉換爲十進制 
 
            二進制轉換爲10進制的規律爲： 每位的值 * 2的（當前位-1次方） 
            例如： 
                00000001 = 0 * 2^7 + 0 * 2^6 + 0 * 2^5 + 0 * 2^4 + 0 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0  = 1 
                00000010 = 0 * 2^7 + 0 * 2^6 + 0 * 2^5 + 0 * 2^4 + 0 * 2^3 + 0 * 2^2 + 1 * 2^1 + 0 * 2^0  = 2 
                 
            2、二進制的符號位： 
                最高位表示符號位，0表示正數  ， 1表示負數 
                 
             
            3、將二進制負數轉換爲十進制：先對該二進制數取反，然後加1，再轉換爲十進制，然後在前面加上負號 
                例如： 10101011 最高位爲1，所以爲負數 
                   第一步：取反： 01010100 
                   第二步：加1 ： 01010101 
                   第三步：轉換爲10進制：85 
                   第四步：加上負號： -85 
                   所以      10101011 轉換爲十進制爲 -85 
                    
            4、將十進制負數轉換爲二進制：先得到該十進制負數的絕對值，然後轉換爲二進制，然後將該二進制取反，然後加1 
                例如：-85 
                第一步：得到絕對值 85 
                第二步：轉換爲二進制：01010101 
                第二步：取反：                10101010 
                第三步：加1：                 10101011 
                所以，-85轉換爲二進制爲  10101011 
         */  
          
        /* 
        ~ ‘非’ 運算符是將目標數的進制去反，即0變成1 ，1變成0 
        2的二進制碼爲 00000010 ， 它取反爲11111101 ，可見取反後結果爲負數（二進制負數轉換爲十進制的步驟爲：將二進制去反，然後+1） 
         將 11111101 轉換爲10進制 ，第一步去反 得到 00000010 然後 加1 得到 00000011 ，得到的結果爲3 ，然後在前面加上負號就可以了 
         所以結果爲-3 
         */  
        System.out.println(~2);  
          
        /* 
          ^ 異或 ，計算方式爲：兩個二進制數的位相同則爲0 不同則爲1 
          23轉換爲二進制爲：00010111 
          12轉換爲二進制爲：00001100 
                    計算結果爲：00011011  =  27 
         */  
        System.out.println(23 ^ 12);   
          
        /* 
         & 按位與 ，計算方式爲：兩個二進制數的位都爲1則爲1 ，否則爲0 
         1的二進制爲 ：00000001 
         2的二進制爲 ：00000010 
              結果爲 :00000000 = 0  
         */  
        System.out.println(1&2);  
          
        /* 
          | 按位或 ，計算方式爲：兩個二進制位有一個爲1就爲1，否者爲0 
          5 的二進制爲：00000101 
          6 的二進制爲：00000110 
                  結果爲：00000111 = 7 
         */  
        System.out.println( 5 | 6);  
          
          
        /* 
          >> 有符號右移位  ，符號左邊表示要被移位的數，右邊表示需要移的位數，結果爲正數則在左邊補0，否則補1 
          3 的二進制爲：00000010 
                向右移動1位：00000001 = 1  
         */  
        System.out.println(3 >> 1);  
          
          
    }  
  
}