java基礎之位運算符

java提供的位運算符有:

第一部分:  &(位與)，|(位或)，^(位異或)，~（位非） 

第二部分:  >>（右移），>>>（無符號右移），<<（左移）

其中除~爲一元操作符，其他的都是二元操作符。 

 根據運算模式不同分爲兩部分

一.第一部分

&,|,^,~ 的運算規則

* &:有0則0

* |:有1則1

* ^:相同則0，不同則1

* ~:按位取反

案例：

1. class Demo1_Operator {
2. public static void main(String[] args) {
3. /*
4. * &,|,^,~ 的用法
5. * &:有0則0
6. * |:有1則1
7. * ^:相同則0，不同則1
8. * ~:按位取反
9. */
10. System.out.println(6 & 3); //2
11. System.out.println(6 | 3); //7
12. System.out.println(6 ^ 3); //5
13. System.out.println(~6); //-7
14. }
15. }

上述代碼是如何運算過程是什麼？

a.  6 & 3 的二進制位運算過程:有0則0

   110

& 011

-----------

    010

b.  6 | 3 的二進制位運算過程:有1則1

       110

   |    011

-------------

       111

c.  6 ^ 3 的二進制位運算過程:相同則0，不同則1

      110

^     011

-------------

      101

d.  6 ^ 3 的二進制位運算過程:按位取反

  00000000 00000000 00000000 00000110    //6的原碼反碼補碼都是本身

  11111111 11111111 11111111 11111001    // 對6取反得補碼

- 00000000 00000000 00000000 00000001    //減1求反碼

-----------------------------------------------------------

11111111 11111111 11111111 11111000      //反碼,對反碼進行除符號位以外其他位上按位取反。

10000000 00000000 00000000 00000111      //求得原碼(-7)

位運算之面試題

核心要點：^的特點：一個數據對另一個數據位異或兩次，該數本身不變。

題目：請自己實現兩個整數變量的交換（不需要定義第三方變量）

案例：

1. class Demo2_Operator {
2. public static void main(String[] args) {
3. /*
4. * 位異或運算符的特點
6. * ^的特點：一個數據對另一個數據位異或兩次，該數本身不變。
7. */
9. int x = 10;
10. int y = 5;
12. //需要第三方變量
13. /*
14. int temp;
15. temp = x; //temp = 10
16. x = y; //x = 5
17. y = temp; //y = 10
18. */
20. //不需要定義第三方變量,有弊端,有可能會超出int的取值範圍
21. /*
22. x = x + y; //10 + 5 = 15
23. y = x - y; //15 - 5 = 10
24. x = x - y; //15 - 10 = 5
25. */
27. //不需要第三方變量,通過^來做
28. x = x ^ y; // 10 ^ 5 
29. y = x ^ y; // 10 ^ 5 ^ 5 y = 10
30. x = x ^ y; // 10 ^ 5 ^ 10  x = 5
32. System.out.println("x = " + x + ",y = " +y);
33. }
34. }

二.第二部分

 >>,>>>,<<的基本運算規則:     a  位移運算符   b  （a表示要進行位移的數，b表示位移的位數）   

1.  <<:左移 左邊最高位丟棄，右邊補齊0

2.  >>:右移 最高位是0，左邊補齊0;最高位是1，左邊補齊1

3.  >>>:無符號右移 無論最高位是0還是1，左邊補齊0(正數適合,負數不適合,負數右移會變成正數)

4.  最有效率的算出2 * 8的結果

案例：

1. class Demo3_Operator {
2. public static void main(String[] args) {
3. /*
4. *  <<:左移 左邊最高位丟棄，右邊補齊0
5. *  >>:右移 最高位是0，左邊補齊0;最高爲是1，左邊補齊1
6. *  >>>:無符號右移 無論最高位是0還是1，左邊補齊0
7. *  最有效率的算出2 * 8的結果
8. */
10. //左移,向左移動幾位就是乘以2的幾次冪
11. //System.out.println(12 << 1); //24
12. //System.out.println(12 << 2); //48
13. /*
14. 00000000 00000000 00000000 00001100 12的補碼
15. (0)0000000 00000000 00000000 000011000 24的補碼
16. [phone] 00000000 00000000 0000110000 48的補碼
17. */
18. //System.out.println(-12 << 1); //-24
19. //System.out.println(-12 << 2); //-48
20. /*
21. 10000000 00000000 00000000 00001100 -12的原碼
22. 11111111 11111111 11111111 11110011 -12的反碼
23. 11111111 11111111 11111111 11110100 -12的補碼
24.         (1)11111111 11111111 11111111 11101000 -24的補碼
25. 11111111 11111111 11111111 11100111 -24的反碼
26. 10000000 00000000 00000000 00011000 -24的原碼
28. */
30. //右移,向右移動幾位就是除以2的幾次冪
31. //System.out.println(12 >> 1); //結果爲 6
32.             //System.out.println(-12 >> 1); //結果爲 -6
33. /*
34. 00000000 00000000 00000000 00001100 12的補碼
35. 00000000 00000000 00000000 00000110 6的補碼
37.                
38. 10000000 00000000 00000000 00001100 -12的原碼
39. 11111111 11111111 11111111 11110011 -12的反碼
40. 11111111 11111111 11111111 11110100 -12的補碼
41.         11111111 11111111 11111111 11111010(0) -6的補碼
42. 11111111 11111111 11111111 11111001 -6的反碼
43. 10000000 00000000 00000000 00000110 -6的原碼
44. */
45.                
46.             //System.out.println(12 >>> 1); //運算規則與>>一樣 結果爲6,在這裏不做位運算詳解了
47.             //System.out.println(-12 >>> 1); // 右移,最高位補0 結果2147483644
49. /*
50.  
51. 10000000 00000000 00000000 00001100 -12的原碼
52. 11111111 11111111 11111111 11110011 -12的反碼
53. 11111111 11111111 11111111 11110100 -12的補碼
54. 01111111 11111111 11111111 11111010(0) 2147483644的補碼
55.                       01111111 11111111 11111111 11111010 2147483644的原碼
56.             */
58. //最有效率的算出2 * 8的結果 ,位運算的效率是比運算符的效率要高的.
59. System.out.println(2 << 3);
61. }
62. }