位运算

数据在计算机中都是以补码形式存放的，位运算也是以一个数的补码进行运算，结果也自然也是一个补码，这点在分析计算过程时非常重要。

编码

原码

原码就是真正存储的数值，比如存个 7，那么它的所有进制表示形式都应该为 7，一个数的原码也就做这个数的真值。例：

[+7] = [0000 0111]原码或真值 = [0000 0111]补码或机器数
[-7] = [1000 0111]原码或真值 = [1111 1001]补码或机器数

反码

正数的反码是其本身，负数的反码是在其原码基础上，符号位不变，其余各个取反。对于反码表示的是负数，人脑是无法直观的看出来它的数值，通常要将其转换成原码。例：

[+1] = [0000 0001]原 = [0000 0001]反
[-1] = [1000 0001]原 = [1111 1110]反

补码

正数的补码就是其本身，负数的补码是在其原码的基础上，符号位不变，其余各位取反，最后加1（即反码加1）。一个数的补码也叫这个数的机器数。对于补码表示的是负数，人脑也是无法直观的看出来它的数值，通常要将其转换成原码。例：

[+1] = [0000 0001]原码或真值 = [0000 0001]反 = [0000 0001]补码或机器数
[-1] = [1000 0001]原码或真值 = [1111 1110]反 = [1111 1111]补码或机器数

有符号数与无符号数

一个数有正负之分，计算机里则为有符号数与无符号数。人脑在计算中用 " + " 号表示正数，用 " - " 减号表示负数，但计算机不能把 " + " 、" - " 号显示出来。计算机中用二进制位最高位表示正负（0正1负）。以8位 int 型为例：

// 无符号 int
[00000000]（最小 0）
[11111111]（最大 2^7 = 127）

// 有符号 int
[01111111]（正数最大   2^7=127）
[11111111]（负数最小 -(2^7 + 1) = -128）

注意：之所以负数会比正数多表示一个数，是因为正0(00000000)，负0(10000000)都表示0，所以前辈们将负0这个状态表示 -128

计算机计算两个数的加减过程

对于数与数之间的运算，人脑可以知道第一位是符号位, 在计算的时候我们会根据符号位, 选择对真值区域的加减。 但是对于计算机, 加减乘数已经是最基础的运算, 要设计的尽量简单. 计算机辨别「符号位」显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道,根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。

分别用原码、反码、补码计算 1 - 1：

// 用原码运算
// 结果显然不对
[0000 0001]原 + [1000 0001]原 = [1000 0010]原 = -2

// 用反码运算
// 结果部分正确，虽然人类看起来 +0 和 -0 是一样的，但是 0 带符号是没有意义的，
// 而且会有 [0000 0000]原 和 [1000 0000]原两种编码表示0;
[0000 0001]反 + [1111 1110]反 = [1111 1111]反 = [1000 0000]原 = -0

// 用补码运算
// 0 用 [0000 0000]原 表示，-0 则不存在了，而且对于一个 8 位二进制数，
// 可以用 [1000 0000]原 表示 -128，即最小值。-128 没有原码和补码表示。
[0000 0001]补 + [1111 1111]补 = [0000 0000]补 = [0000 0000]原 = 0

从上面的运算结果来看，只有用补码运算结果最准确，下面进一步用补码运算验证：

6 - 5 = ?

6  的补码为：0000 0110
               +
-5 的补码为：1111 1011
               =
           0000 0001 
正数 3 种编码方式相同，所以原码也为 0000 0001，对应十进制为：1

-6 - 5 = ?

-6  补码为：1111 1010
                +
-5  补码为：1111 1011
                =
           1111 0101 
补码为负数，原码为：1000 1011 ，对应十进制为：-11

小结

• 一个正数的原码、反码、补码 3 种编码方式结果相同，而对于一个负数，3 种编码方式是完全不同的。
• [负数]原 = 负数补码再求补码
• 在计算机内部，二进制加法是基本运算，而二进制的减法则是采用补码运算，将减法转换成加法实现的；二进制乘、除法运算可以通过加、减和移位来实现。 二进制数中小数点向右移 1 位，数值就扩大2倍；小数点向左移 1 位，数值就缩小 2 倍。

位操作符

<<

左移位，移动位置为从左至右第一个出现 1 的位置开始，低位补 0，高位丢失。如需要了解移动过程，请参考下面的例子：

// 下面以数字 13 为例，因为 13 为正数，所以原码、反码、补码都相同，即：
// 13[原][反][补] = 0000 1101

// 例1：13 << 2
// 0000 1101 左移 2 位得到的结果为：0011 0100
// 很明显，0011 0100 为一正数，所以其对应的原码也是 0011 0100，对应的十进制为：52
System.out.println(13 << 2);// 输出：52

// 例2：13 << 4
// 0000 1101 左移 4 位得到的结果补码为：1101 0000
// 因为 1101 0000 是一正数，所以其对应的原码也是 1101 0000，对应的十进制为：208
// 
// 「 注意 」！！！！！：
// 1101 0000 中 的 1101 并不是处于最高位，它前面还有多位，只是我们为了方便没写出来。
// 下面一个例子将验证最高位到底在哪一位
System.out.println(13 << 4);// 输出：208

// 例3：13 << 28
// 首先，一个数有可能是32位、64位，我们猜测它是 32 位的，那么 13 的补码就该写为：
// 0000 0000 0000 0000 0000 0000 0000 1101
// 如果这个数是 32 位的，且 1101 要处于最高位，那么观察上面的数，至少需要左移 28 位，移动后为：
// 1101 0000 0000 0000 0000 0000 0000 0000
// 注意，移位后的这个数依然是一个补码，如果我们猜测的 32 位数没错，那么最高位就应该是符号位
// 左移 28 位后应该就为一个负数了，其原码为：
// 1011 0000 0000 0000 0000 0000 0000 0000，对应的十进制数为：-805306368
// 从下面的输出来看，我们的猜测是正确的
//
// 「 注意 」！！！！！：
// 有可能和具体设备有关，但难思路都相同
System.out.println(13 << 28);// 输出：-805306368

// 例4：13 << 32
// 从上面的 例3 中可以后出，这是一个 32 位数，如果我们向左移动 32 位会怎样？
// 从输出可以看出，其值为13，也就是说这个数又回到了正常的形式，即：
// 0000 0000 0000 0000 0000 0000 0000 1101
System.out.println(13 << 32);// 输出：13

// 例5：-13 << 4
// -13 的补码为：
// 1111 1111 1111 1111 1111 1111 1111 0011
// 左移 4 位后：
// 1111 1111 1111 1111 1111 1111 0011 0000
// 对应原码为：
// 1000 0000 0000 0000 0000 0000 1101 0000
// 对应十进制为：
// -208
System.out.println(-13 << 4); // 输出：-208

>>

右移位，移动位置为从左至右第一个出现 1 的位置开始，高位根据符号位进行补位，符号位是 0 补 0，是 1 补 1，低位丢失。例：

// 例1：-13 >> 4
// -13 的补码为：
// 1111 1111 1111 1111 1111 1111 1111 0011
// 右移 4 位后：
// 1111 1111 1111 1111 1111 1111 1111 1111
// 对应原码：
// 1000 0000 0000 0000 0000 0000 0000 0001
// 对应十进制为：
// -1
System.out.println(-13 >> 4); // 输出：-1

// 例2：13 >> 4
// 13 的补码为：
// 0000 0000 0000 0000 0000 0000 0000 1101
// 右移 4 位后
// 0000 0000 0000 0000 0000 0000 0000 0000
// 对应十进制为：
// 0
System.out.println(13 >> 4);// 输出：0

// 例3：7 >> 2
// 7 的补码为：
// 0000 0000 0000 0000 0000 0000 0000 0111
// 右移 2 位后
// 0000 0000 0000 0000 0000 0000 0000 0001
// 对应十进制为：
// 1
System.out.println(7 >> 2);// 输出：1

>>>

无符号右移，只对 32 位与 64 位数有意义。对于正数，>> 与 >>> 结果都是一样的; 负数时，>> 高位用 1 补上，>>> 高位用 0 补上。

& (位与运算符)

只有 1 & 1 = 1，其它都为 0。例：

// 6 & 5
// 6对应补码为：     0000 0110
//                     &
// 5对应补码为：     0000 0101 
//                     =
// 补码结果为：      0000 0100
// 正数的 3 种编码方式相同，所以 0000 0100 原码也是 0000 0100 ，对应十进制为：4

| (位或运算符)

只有 0 | 0 = 0，其它都为 1。例：

// 6 | 5
// 6对应补码为：     0000 0110
//                     |
// 5对应补码为：     0000 0101 
//                     =
// 补码运算结果为：   0000 0111
// 正数的 3 种编码方式相同，所以 0000 0111 的原码也为 0000 0111，对应的十进制为：7

~ (位非运算符)

0 变 1，1 变 0，且这个位运算符是一个单目运算符，不能写成 x ~ y 的形式。例：

// 例 1：～-6
// -6 原码为：
// 1000 0000 0000 0000 0000 0000 0000 0110
// 补码为：
// 1111 1111 1111 1111 1111 1111 1111 1010
// 进行位非运算后：
// 0000 0000 0000 0000 0000 0000 0000 0101
// 正数原码、反码、补码相同，所以对应十进制为：
// 5

^ (位异或运算符)

1 ^ 0 = 1，其它都为 0。例：

// 6^5
// 6对应补码为：     0000 0110
//                     ^
// 5对应补码为：     0000 0101
//                     =    
// 补码运算结果为：   0000 0011
// 正数的 3 种编码方式相同，所以 0000 0011 的原码也为 0000 0011，对应的十进制为：3

& 做逻辑运算符与 && 的区别

不管 & 前面的表达式的结果为 true 或 false 后面的表达式都会参加计算。只要 && 前面的表达式为 false，则后面的表达式不参加运算。例：

int i = 1;
boolean b = i++ > 5 & i++ < 10;
// 结果为：b = false；i = 3；

boolean bb = i++ > 5 && i++ < 10;
// 结果为：bb = false；i = 2；

| 做逻辑运算符与 || 的区别

不管 | 前面的表达式的结果为 true 或 false 后面的表达式都会参加计算。
只要 || 前面的表达式为 true，则后面的表达式不参加运算。例：

int i = 1;
boolean b = i++ < 5 | i++ < 10;
// 结果为：b = true；i = 3；

boolean bb = i++ < 5 || i++ < 10;
// 结果为：bb = true；i = 2；

位运算用途

乘以、除以 2^n

x << n（乘以 2^n）
x >> n（除以 2^n）

判断一个数是奇数还是偶数

x & 1（结果只有 0 和 1 两种情况，0 为偶数，1 为奇数）
x & 2 (结果只有 0 和 2 两种情况，可做两种条件的判断)

求两个数的平均数

(x & y) + ( ( x ^ y ) >> 1)

两个数交换

x ^= y;
y ^= x;
x ^= y;

求相反数

~x + 1

提高运算效率

可提高运算效率，处理器能够直接支持

高级用法

权限管理、数据加密等，利用位运算可做的东西深不可测。