逻辑运算符与位运算符

一、逻辑运算符

逻辑运算符有：&（且）、&&、|（或）、||、^（异或）、！（非）

&（且）运算符：运算符两边只要有 false 则结果为 false，
|（或）运算符：运算符两边只要有 true 则结果为 true，
^（异或）运算符：运算符两边同为 false 或 true 则结果为 false，如果不相同则结果为 true,
！（非）运算符：就是逻辑非，取反，如：运算符后是 false，则结果为 true。

& 与 &&、| 与 || 的最终结果是一样的，但是他们之间还是有区别的：

&& 运算符：具有短路效果，如果运算符左边为 false，右边将不再执行直接给出结果为 false。
而 & 运算符：即使运算符左边已经为 false，还是会执行运算符右边，最后再结合起来判断得出最后结果为 false。
| 运算符与 || 运算符类似。
1
2
3

二、位运算符

位运算符有：&、|、^、~、<<、>>、<<<、>>>

注意：如果 &、|、^ 这三个运算符两边是数值则为位运算符，如果两边是 boolean 类型值则作为逻辑运算符。

位运算符：进行的操作都是二进制的，也就是说在操作之前需要先把数据转换为二进制数。

1、&、|、^、~ 位运算符

以下面代码为例：

public class Test {

    public static void main(String[] args) {

        int a = 3;
        int b = 4;

        System.out.println("3 & 4 = " + (a & b));
        System.out.println("3 | 4 = " + (a | b));
        System.out.println("3 ^ 4 = " + (a ^ b));
        System.out.println("~3 = " + (~a));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3 的二进制数（int类型的值占4个字节，32位二进制数）：

00000000  00000000  00000000  00000011
1

4 的二进制数：

00000000  00000000  00000000  00000100
1

& 运算符：有0则0
以 3 & 4 为例

  00000000  00000000  00000000  00000011
& 00000000  00000000  00000000  00000100
------------------------------------------
  00000000  00000000  00000000  00000000   					--也就是十进制的 0
1
2
3
4

| 运算符：有1则1
以 3 | 4 为例：

  00000000  00000000  00000000  00000011
| 00000000  00000000  00000000  00000100
------------------------------------------
  00000000  00000000  00000000  00000111					--也就是十进制的 7
1
2
3
4

^ 运算符：相同则0，不相同则1
以 3 ^ 4为例：

  00000000  00000000  00000000  00000011
^ 00000000  00000000  00000000  00000100
------------------------------------------
  00000000  00000000  00000000  00000111					--也就是十进制的7
1
2
3
4

~ 运算符：按位取反
以 ~ 3 为例：

~ 00000000  00000000  00000000  00000011
------------------------------------------
  11111111  11111111  11111111  11111100        --这里得到的是最后结果的补码

  11111111  11111111  11111111  11111011        --最后结果的反码
  10000000  00000000  00000000  00000100		--最后结果的原码，最后结果即十进制的 -4
1
2
3
4
5
6

最后的运行结果：

2、<<、>>、>>> 位运算符

以下面代码为例：

public class Test {

    public static void main(String[] args) {

        int a = 16;

        System.out.println("16 << 2的结果：" + (a << 2));
        System.out.println("16 >> 2的结果：" + (a >> 2));
        System.out.println("-16 >> 2的结果：" + (-16 >> 2));
        System.out.println("16 >>> 2的结果：" + (a >>> 2));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

16 的二进制数：

00000000  00000000  00000000  00010000
1

<< 运算符：把数据向左移动指定位数，右边补0，相当于乘以 2 的移动位数次幂。
以 16 << 2 为例：

          00000000  00000000  00000000  00010000
      (00)000000  00000000  00000000  0001000000
      即  00000000  00000000  00000000  01000000  		 --也就是十进制的 64
1
2
3

>> 运算符（有符号右移）：

• 正数右移：把数据向右移动指定位数，左边补0，相当于除以 2 的移动位数次幂。
  以16 >> 2 为例：

    	 00000000  00000000  00000000  00010000
    	 0000000000  00000000  00000000  000100(00)
    即 00000000  00000000  00000000  00000100			--也就是十进制的 4
  1
  2
  3

• 负数右移：把数据向右移动制定位数，左边补1，相当于除以 2 的移动位数次幂。
  首先得求得负数的补码，再对其进行移位操作
  以 -16 >> 2 为例：

  首先 -16 的二进制原码：

    10000000  00000000  00000000  00010000
  1

  -16 的反码（负数符号位不变，其他位取反）：

    11111111  11111111  11111111  11101111
  1

  -16 的补码（反码加 1）：

    11111111  11111111  11111111  11110000
  1

  对其补码进行右移2位：

    11111111  11111111  11111111  11111100(00)
  1

  将移位后的补码 -1得到移位后的结果数的反码：

    11111111  11111111  11111111  11111011
  1

  再将刚才得到的移位后结果的反码取反得到原码（负数符号位不变，其他位取反）：

    10000000  00000000  00000000  00000100
    这个就是最终的结果的二进制数，即为十进制的 -4
  1
  2

补充一句：正数的原码、反码、补码相同。

>>> 运算符（无符号右移）：
无论是正数还是负数，向右移动指定位数，左边都是补0，相当于除以 2 的移动位数次幂。（这个类似于正数的右移）

最后的运行结果