java 位操作 bitwise(按位) operation bit

java 位操作 bitwise(按位) operation bit

//一篇对于 原码 反码 补码 的介绍

http://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html

java中有三种移位运算符

<<      :     左移运算符，num << 1,相当于num乘以2

>>      :     右移运算符，num >> 1,相当于num除以2

>>>    :     无符号右移，忽略符号位，空位都以0补齐

// 8   0000 0000 0000 1000     原码
    　 1111 1111 1111 0111     反码

+　　　　　　　　　　　　  1

　　　1111 1111 1111 1000     （8的补码）来表示 -8

// -8 1111 1111 1111 1000 65528     补码（正值 的反码+1）

// 65535 1111 1111 1111 1111 65535
// 65535-65528=7+1=8

 

操作longValue = longValue | (1 << n); 可以在longValue的2进制表示中，把从右边数到左边数第n + 1位的值设置为1，并且不影响其他位上面的值   即用0和2进制值变量x做或|or操作，不会影响到2进制变量x的值

操作longValue = longValue & ~(1 << n); 可以在longValue的2进制表示中，把从右边数到左边数第n + 1位设置为0，并且不影响其他位上面的值   即用1和2进制值变量x做与&and操作，不会影响到2进制变量x的值

操作System.out.println((longValue >> n & 1) == 1); 可以判断值longValue的2进制表示中，从右边数到左边第n + 1位的值是0false 还是1true

1. public class bitOperation {
2. /**
3. * @param args
4. */
5. public static void main(String[] args) {
6. long longValue = 0;
7. longValue = longValue | (1 << 0);
8. // 1
9. System.out.println(Long.toBinaryString(longValue));
10. longValue = longValue | (1 << 1);
11. // 11
12. System.out.println(Long.toBinaryString(longValue));
13. longValue = longValue | (1 << 4);
14. // 10011
15. System.out.println(Long.toBinaryString(longValue));
16. longValue = longValue | (1 << 5);
17. // 110011
18. System.out.println(Long.toBinaryString(longValue));
19. longValue = longValue | (1 << 6);
20. // 1110011
21. System.out.println(Long.toBinaryString(longValue));
22. String hex = Long.toBinaryString(longValue);
23. // 1110011
24. System.out.println(hex);
25. // 115
26. System.out.println(Integer.valueOf("1110011", 2));
27. // 1110011
28. System.out.println(Long.toBinaryString(longValue >> 0));
29. // 1
30. System.out.println(Long.toBinaryString(longValue >> 0 & 1));
31. // 111001
32. System.out.println(Long.toBinaryString(longValue >> 1));
33. // 1
34. System.out.println(Long.toBinaryString(longValue >> 1 & 1));
35. // true
36. System.out.println((longValue >> 0 & 1) == 1);
37. // true
38. System.out.println((longValue >> 1 & 1) == 1);
39. // false
40. System.out.println((longValue >> 2 & 1) == 1);
41. // false
42. System.out.println((longValue >> 3 & 1) == 1);
43. // true
44. System.out.println((longValue >> 4 & 1) == 1);
45. // true
46. System.out.println((longValue >> 5 & 1) == 1);
47. // true
48. System.out.println((longValue >> 6 & 1) == 1);
49. // false
50. System.out.println((longValue >> 7 & 1) == 1);
51. // Demonstrate the bitwise logical operators.
52. bitLogic();
53. // Left shifting a byte value.
54. byteShift();
55. }
56. /**
57. * Left shifting a byte value.
58. */
59. private static void byteShift() {
60. byte a = 64, b;
61. int i;
62. i = a << 2;
63. b = (byte) (a << 2);
64. // Original value of a: 64
65. System.out.println("Original value of a: " + a);
66. // i and b: 256 0
67. System.out.println("i and b: " + i + " " + b);
68. System.out.println("\r\n");
69. }
70. /**
71. * Demonstrate the bitwise logical operators.
72. */
73. private static void bitLogic() {
74. String binary[] = { "0000", "0001", "0010", "0011", "0100", "0101",
75. "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101",
76. "1110", "1111"
77. };
78. int a = 3; // 0 + 2 + 1 or 0011 in binary
79. int b = 6; // 4 + 2 + 0 or 0110 in binary
80. int c = a | b;
81. int d = a & b;
82. int e = a ^ b;
83. int f = (~a & b) | (a & ~b);
84. int g = ~a & 0x0f;
85. // a = 0011 = 3
86. System.out.println(" a = " + binary[a] + " = " + a);
87. // b = 0110 = 6
88. System.out.println(" b = " + binary[b] + " = " + b);
89. // a|b = 0111 = 7
90. System.out.println(" a|b = " + binary[c] + " = " + c);
91. // a&b = 0010 = 2
92. System.out.println(" a&b = " + binary[d] + " = " + d);
93. // a^b = 0101 = 5
94. System.out.println(" a^b = " + binary[e] + " = " + e);
95. // ~a&b|a&~b = 0101 = 5
96. System.out.println("~a&b|a&~b = " + binary[f] + " = " + f);
97. // ~a = 1100 = 12
98. System.out.println(" ~a = " + binary[g] + " = " + g);
99. System.out.println("\r\n");
100. }
101. }