Java 中位运算，原码，反码，补码的详解

博主前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住也分享一下给大家，
👉点击跳转到网站

首先是关于原码，反码，补码的规则的掌握

1. 二进制的最高位是符号位：0表示正数，1表示负数（口诀：0->0 1-> -）
2. 正数的原码，反码，补码都一样（三码合一）
3. 负数的反码=它的原码符号位不变，其他位取反（0->1 , 1->0）
4. 负数的补码=它的反码+1，负数的反码=负数的补码-1
5. 0的反码，补码都是0
6. java没有无符号数，换言之，java中的数都是有符号的。
7. 在计算机运算的时候，都是以补码的方式来运算的。
8. 当我们看运算结果的时候，要看他的原码

下面我们就来看java中的位运算符

java中有七个位运算符(&、|、^、~、>>、<<和>>>)

首先先看前四个它们的运算规则：

1. 按位与&：两位全为1，结果为1，否则为0
2. 按位或|：两位有一个为1，结果为1，否则为0
3. 按位异或^：两位有一个为1，有一个为0，结果为1，否则为0
4. 按位取反~：0->1，1->0

下面我们通过一个具体的例子，来理解位运算：

public class BitOperator {
    public static void main(String[] args) {

        //推导过程
        //1. 先得到2的补码，只有先得到 2的原码=>00000000 00000000 00000000 00000010 因为符号位最高位为0，表示是正数(三码合一 所以2的补码跟原码一样)
        //   2的补码：00000000 00000000 00000000 00000010
        //2. 3的原码=>00000000 00000000 00000000 00000011
        //   3的补码=>00000000 00000000 00000000 00000011

        //3. 进行位运算，按位与&(运算规则：两位全为1，结果为1，否则为0)
        // 2的补码：00000000 00000000 00000000 00000010
        // 3的补码：00000000 00000000 00000000 00000011
        // 按位与&后的补码为：00000000 00000000 00000000 00000010
        //因为运算后的补码的符号位为正数(三码合一)，所以原码也是：00000000 00000000 00000000 00000010 (二进制转十进制结果为2,所以输出结果为2)
        System.out.println(2&3);  //输出结果为2

		//推导
        //1.先得到-2的原码： 10000000 00000000 00000000 00000010
        //2.得到-2的反码：11111111 11111111 11111111 11111101
        //3.得到-2的补码才能进行运算：11111111 11111111 11111111 11111110
        //4.~按位取反~：0->1，1->0 :00000000 00000000 00000000 00000001 这是运算后的补码
        //5.看结果的话，看运算后补码对应的原码：运算后的补码的最高位为0 为正数，所以运算后的原码就是
        //00000000 00000000 00000000 00000001
        System.out.println(~-2); //1

        //推导
        //1.先得到2的原码： 00000000 00000000 00000000 00000010
        //2.得到2的补码(正数原码，反码，补码都一样)才能进行运算：00000000 00000000 00000000 00000010
        //3.~按位取反~：0->1，1->0 :11111111 11111111 11111111 11111101 这是运算后的补码
        //看结果的话，看运算后补码对应的原码：运算后的补码的最高位为1 为负数，所以要先求反码
        //4.运算后的反码为:11111111 11111111 11111111 11111100
        //5.运算后的原码为：符号位不变，其他位取反 10000000 00000000 00000000 00000011
        System.out.println(~2); //-3

		//1.2的原码为：00000000 00000000 00000000 00000010
        //2.2的补码为：00000000 00000000 00000000 00000010

        //3.3的原码为：00000000 00000000 00000000 00000011
        //3.3的补码为：00000000 00000000 00000000 00000011

        //4.2|3 按位或|：两位有一个为1，结果为1，否则为0
        //5.运算后的补码为：00000000 00000000 00000000 00000011
        //正数的原码跟补码相等,所以原码为：00000000 00000000 00000000 00000011
        System.out.println(2 | 3);//3


        //1.2的原码为：00000000 00000000 00000000 00000010
        //2.2的补码为：00000000 00000000 00000000 00000010

        //3.3的原码为：00000000 00000000 00000000 00000011
        //3.3的补码为：00000000 00000000 00000000 00000011

        //4.2^3 按位异或^：两位有一个为1，有一个为0，结果为1，否则为0
        //运算后的补码为：00000000 00000000 00000000 00000001
        //正数的原码跟补码相等,所以原码为：00000000 00000000 00000000 00000001
        System.out.println(2 ^ 3); //1
    }
}

最后看另外三个位运算符的运算规则：

1. 算术右移>>：低位溢出，符号位不变，若符号为正，则在高位插入0；若符号为负，则在高位插入1
2. 算术左移<<：符号位不变，低位补0
3. 逻辑右移也叫无符号右移> > > :低位溢出，高位补0
4. 特别说明：没有符号<<<

下面我们通过具体的例子，来理解一下：

 //00000000 00000000 00000000 00000001=>00000000 00000000 00000000 00000000 本质1/2/2=0
        int a = 1>>2;
        System.out.println(a); //0

        //00000000 00000000 00000000 00000001=>00000000 00000000 00000000 00000100 本质1*2*2=4
        int b = 1<<2;
        System.out.println(b); //4

        int c = 4>>3; //同理 4/2/2/2=0
        System.out.println(c); //0

        //15的二进制为： 00000000 00000000 00000000 00001111 =>向右移两位为：00000000 00000000 00000000 00000011
        int d = 15>>2; //同理 15/2/2=3
        System.out.println(d); //3

        int e = 4<<3; //同理：4*2*2*2=32
        System.out.println(e); //32

		int a = 1 >> 2; //1算术右移2位

        //-1的原码为： 10000000 00000000 00000000 00000001
        //-1的反码为： 11111111 11111111 11111111 11111110
        //-1的补码为： 11111111 11111111 11111111 11111111
        //低位溢出，符号位不变，若符号为正，则在高位插入0；若符号为负，则在高位插入1
        //运算后的补码为：11111111 11111111 11111111 11111111 运算后补码的最高位为：1 为负数 所以要先求反码
        //反码为(负数的补码-1)：11111111 11111111 11111111 11111110
        //运算后的原码为：10000000 00000000 00000000 00000001 所以结果为-1
        int b = -1 >> 2; //-1算术右移2位
        System.out.println(a); //0
        System.out.println(b); //-1

        //00000000 00000000 00000000 00000001
        //算术左移两位变为：
        //00000000 00000000 00000000 00000100
        int c = 1 << 2; //1算术左移2位

        //-1的原码为： 10000000 00000000 00000000 00000001
        //-1的反码为： 11111111 11111111 11111111 11111110
        //-1的补码为： 11111111 11111111 11111111 11111111
        //-1 算术左移2位
        //运算后的补码为：11111111 11111111 11111111 11111100 运算后补码的最高位为：1 为负数 所以要先求反码
        //反码为(负数的补码-1)：11111111 11111111 11111111 11111011
        //运算后的原码为：10000000 00000000 00000000 00000100 所以结果为-4
        int d = -1 << 2; //-1 算术左移2位

        //00000000 00000000 00000000 00000011
        //无符号右移两位变为：
        //00000000 00000000 00000000 00000000
        int e = 3 >>> 2; //3无符号右移2位
        System.out.println(c); //4
        System.out.println(d); //-4
        System.out.println(e); //0