Java二进制位运算符

1.简述

　　看这篇文章之前首先了解一下原码，反码，补码的概念。https://www.cnblogs.com/bl123/p/13730998.html

　　需要注意的是，二进制都是从高位到低位。

2.位运算符分类

符号	描述	运算规则
&	与	按位与，如果对应的二进制位同时为 1，那么计算结果才为 1；否则为 0。因此，任何数与 0 进行按位与运算，其结果都为 0。
|	或	按位或，如果对应的二进制位只要有一个为 1，那么结果就为 1；如果对应的二进制位都为 0，结果才为 0。
^	异或	按位异或，如果对应的二进制位相同（同时为 0 或同时为 1）时，结果为 0；如果对应的二进制位不相同，结果则为 1。
~	取反	按位取反，只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1。
>>	右移	有符号按位右移，只对一个操作数进行运算，将操作数二进制形式向右移动对应的位数，低位移出（舍弃），高位的空位补零。
<<	左移	按位左移，只对一个操作数进行运算，将操作数二进制形式向左移动对应的位数，高位移出（舍弃），低位的空位补零。
>>>	无符号右移	无符号按位右移，只对一个操作数进行运算，将操作数按二进制形式忽略符号位的右移，空位都以0补齐。

3.分类中各种位运算符简述

（1）&（与运算）

　　参加运算的两个数据，按二进制位进行“与”运算。

　　运算规则：0 & 0 = 0、0 & 1 = 0、1 & 0 = 0、1 & 1 = 1。即：两位同时为1，结果才为1，否则为0。

　　示例如下：

public class Test{
    public static void main(String[] args) {
        System.out.println(binaryToDecimal(3));
        System.out.println(binaryToDecimal(5));
        System.out.println(binaryToDecimal(3 & 5));
        System.out.println(3 & 5);
    }
    
    /**将10进制转为2进制字符串
     */
    private static String binaryToDecimal(int num) {
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toBinaryString(num));//是有jdk自带方法转为二进制
        int length = sb.length();
        for (int i = 0; i < 16 - length; i++) {//补齐16位
            sb.insert(0, 0);
        }
        length = sb.length();
        for (int i = 0; i < length; i++) {
            if((i + 1) % 5 == 0)
                sb.insert(i, " ");
        }
        return sb.toString();
    }
}

运行结果

0000 0000 0000 0011

0000 0000 0000 0101

0000 0000 0000 0001

1

　　根据示例的输出结果我们可以得出，3 & 5即0000 0000 0000 0011 & 0000 0000 0000 0101 = 0000 0000 0000 0001因此，3 & 5的值等于1。

（2）|（或运算）

　　参与运算的两个数据，按照二进制位进行“或”运算。

　　运算规则：0 & 0 = 0、0 & 1 = 1、1 & 0 = 1、1 & 1 = 1。即：参与运算的两个数据只要有一个值为1 那么值为1。

　　示例如下：

public class Test{
    public static void main(String[] args) {
        System.out.println(binaryToDecimal(3));
        System.out.println(binaryToDecimal(5));
        System.out.println(binaryToDecimal(3 | 5));
        System.out.println(3 | 5);
    }
    
    /**将10进制转为2进制字符串
     */
    private static String binaryToDecimal(int num) {
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toBinaryString(num));//是有jdk自带方法转为二进制
        int length = sb.length();
        for (int i = 0; i < 16 - length; i++) {//补齐16位
            sb.insert(0, 0);
        }
        length = sb.length();
        for (int i = 0; i < length; i++) {
            if((i + 1) % 5 == 0)
                sb.insert(i, " ");
        }
        return sb.toString();
    }
}

运行结果

0000 0000 0000 0011

0000 0000 0000 0101

0000 0000 0000 0111

7

　　根据示例的输出结果我们可以得出，3 | 5即0000 0000 0000 0011 | 0000 0000 0000 0101 = 0000 0000 0000 0111因此，3 | 5的值等于7。

（3）^（异或运算）

　　参与运算的两个数据，按照二进制位进行“异或”运算。

　　运算规则：0 & 0 = 0、0 & 1 = 1、1 & 0 = 1、1 & 1 = 0。即：参加运算的两个对象，如果两个相应位值不同，则该位结果为1，否则为0。

　　示例如下：

public class Test{
    public static void main(String[] args) {
        System.out.println(binaryToDecimal(3));
        System.out.println(binaryToDecimal(5));
        System.out.println(binaryToDecimal(3 ^ 5));
        System.out.println(3 ^ 5);
    }
    
    /**将10进制转为2进制字符串
     */
    private static String binaryToDecimal(int num) {
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toBinaryString(num));//是有jdk自带方法转为二进制
        int length = sb.length();
        for (int i = 0; i < 16 - length; i++) {//补齐16位
            sb.insert(0, 0);
        }
        length = sb.length();
        for (int i = 0; i < length; i++) {
            if((i + 1) % 5 == 0)
                sb.insert(i, " ");
        }
        return sb.toString();
    }
}

运行结果

0000 0000 0000 0011

0000 0000 0000 0101

0000 0000 0000 0110

6

　　根据示例的输出结果我们可以得出，3 ^ 5即0000 0000 0000 0011 ^ 0000 0000 0000 0101 = 0000 0000 0000 0110因此，3 ^ 5的值等于6。

（4）~（取反运算）

　　参与取反的一个数据，按照二进制位进行“取反”运算。

　　取反规则：1 = 0、0 = 1。即：参加取反的一个对象，如果相应位值为0，则该位结果为1，否则为0。

　　示例如下：

public class Test{
    public static void main(String[] args) {
        System.out.println(binaryToDecimal(3));
        System.out.println(binaryToDecimal(~3));
    }
    
    /**将10进制转为2进制字符串
     */
    private static String binaryToDecimal(int num) {
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toBinaryString(num));//是有jdk自带方法转为二进制
        int length = sb.length();
        for (int i = 0; i < 32 - length; i++) {//补齐16位
            sb.insert(0, 0);
        }
        length = sb.length();
        for (int i = 0; i < length + 3; i++) {
            if((i + 1) % 5 == 0)
                sb.insert(i, " ");
        }
        return sb.toString();
    }
}

运行结果

0000 0000 0000 0000 0000 0000 0000 0011

1111 1111 1111 1111 1111 1111 1111 1100

　　根据示例的输出结果我们可以得出，~3即0000 0000 0000 0000 0000 0000 0000 0011 = 1111 1111 1111 1111 1111 1111 1111 1100。

（5）>>（右移运算）

　　参与右移的一个数据，按照二进制位进行“右移”运算。

　　示例如下：

public class Test{
    public static void main(String[] args) {
        System.out.println(binaryToDecimal(-256));
        System.out.println(binaryToDecimal(-256 >> 4));
    }
    
    /**将10进制转为2进制字符串
     */
    private static String binaryToDecimal(int num) {
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toBinaryString(num));//是有jdk自带方法转为二进制
        int length = sb.length();
        for (int i = 0; i < 16 - length; i++) {//补齐16位
            sb.insert(0, 0);
        }
        length = sb.length();
        for (int i = 0; i < length + 3; i++) {
            if((i + 1) % 5 == 0)
                sb.insert(i, " ");
        }
        return sb.toString();
    }
}

运行结果

1111 1111 1111 1111 1111 1111 0000 0000

1111 1111 1111 1111 1111 1111 1111 0000

　　根据示例的输出结果我们可以看到，二进制数向右边移动了4位，因为是有符号的右移，所以如果是负数的话，那就会补充1，正数则补充0。

（6）<<（左移运算）

　　参与左移的一个数据，按照二进制位进行“左移”运算。

　　示例如下：

public class Test{
    public static void main(String[] args) {
        System.out.println(binaryToDecimal(-256));
        System.out.println(binaryToDecimal(-256 << 4));
    }
    
    /**将10进制转为2进制字符串
     */
    private static String binaryToDecimal(int num) {
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toBinaryString(num));//是有jdk自带方法转为二进制
        int length = sb.length();
        for (int i = 0; i < 32 - length; i++) {//补齐16位
            sb.insert(0, 0);
        }
        length = sb.length();
        for (int i = 0; i < length + 3; i++) {
            if((i + 1) % 5 == 0)
                sb.insert(i, " ");
        }
        return sb.toString();
    }
}

运行结果

1111 1111 1111 1111 1111 1111 0000 0000

1111 1111 1111 1111 1111 0000 0000 0000

　　根据示例的输出结果我们可以看到，二进制数向左边移动了4位，空位补充0。

（7）>>>（无符号右移运算）

　　参与无符号右移的一个数据，按照二进制位进行“无符号右移”运算。

　　示例如下：

public class Test{
    public static void main(String[] args) {
        System.out.println(binaryToDecimal(-256));
        System.out.println(binaryToDecimal(-256 >>> 4));
    }
    
    /**将10进制转为2进制字符串
     */
    private static String binaryToDecimal(int num) {
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toBinaryString(num));//是有jdk自带方法转为二进制
        int length = sb.length();
        for (int i = 0; i < 32 - length; i++) {//补齐16位
            sb.insert(0, 0);
        }
        length = sb.length();
        for (int i = 0; i < length + 3; i++) {
            if((i + 1) % 5 == 0)
                sb.insert(i, " ");
        }
        return sb.toString();
    }
}

运行结果

1111 1111 1111 1111 1111 1111 0000 0000

0000 1111 1111 1111 1111 1111 1111 0000

　　根据示例的输出结果我们可以看到，二进制数向右边移动了4位，因为是无符号右移所以空位直接补充0。