Java的位運算子詳解例項——與(&)、非(~)、或(|)、異或(^)

_賴寶發表於2012-10-25

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

 


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、當兩個運算元型別不相同時,運算元在運算前會子鬆向上造型成相同的型別,再進行運算。

示例如下:

 

  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為例,程式碼如下:

  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*2y ;x>>y相當於x/2y
    從計算速度上講,移位運算要比算術運算快。
    如果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,後面的程式碼就不執行了。
“短路”現象在多重判斷和邏輯處理中非常有用。我們經常這樣使用:

  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

示例如下:

  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);
		
		
	}

}


相關文章