位运算符(&,|,~,^,同或,＞＞,＜＜)

目录

1.按位与（&）

2.按位或（|）

3.按位取反（~）

4.异或（^）

5.同或

6.左移（<<）

7.右移（>>）

---

什么是位运算符:

位运算是直接对整型数据的二进制进行运算。

1.按位与（&）

将参加运算的两个数据，按二进制位进行"与"运算。两个都是一则为一

举例: 3 & 5

3 => 0000 0000 0000 0011

5 => 0000 0000 0000 0101

&      0000 0000 0000 0001 转换成十进制也就是1

2.按位或（|）

将参加运算的两个数据，按二进制位进行"或"运算。两个中有一个是一则为一

举例: 3 | 5

3 => 0000 0000 0000 0011

5 => 0000 0000 0000 0101

|       0000 0000 0000 0111 转换成十进制也就是7

 

3.按位取反（~）

将数据，按二进制位进行"取反"运算。零变成一，一变成零

举例: ~6

6 => 0000 0000 0000 0110

~      1111 1111 1111 1001 转换成十进制也就是-7

4.异或（^）

将参加运算的两个数据，按二进制位进行"与"运算。相同为零，不同为一

举例: 3 ^ 5

3 => 0000 0000 0000 0011

5 => 0000 0000 0000 0101

^      0000 0000 0000 0110 转换成十进制也就是6

运算法则:

1. n ^ 0 = n
2. n ^ n = 0       
3. a ^ b = b ^ a
4. a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ c;
5. d = a ^ b ^ c       a ^ b ^ a = b.          可以推出 a = d ^ b ^ c.

力扣 一道算法题: 找出只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例 2:

输入: [4,1,2,1,2]
输出: 4

不用异或写法:  代码不简洁 且时间复杂度高

class Solution {
    public int singleNumber(int[] nums) {
        boolean flag;
        for (int i = 0; i < nums.length; i++) {
            flag = false;
            for (int j = 0; j < nums.length; j++) {
                if (nums[i] == nums[j] && i != j) {
                    flag = true;
                    break;
                }
            }
            if (!flag) {
                return nums[i];
            }
        }
        return -1;
    }
}

异或写法: 

class Solution {
    public int singleNumber(int[] nums) {
        int n = 0;
        for(int i = 0; i < nums.length; i++){
            n ^= nums[i];   //异或运算
        }
        return n;
    }
}

5.同或

将参加运算的两个数据，按二进制位进行"同或"运算。相同为一，不同为零

举例: 3 同或 5

 

3 => 0000 0000 0000 0011

5 => 0000 0000 0000 0101

        1111 1111 1111 0001 转换成十进制也就是-7

java语言中只有异或(^)没有同或符号

但是可以用代码实现 A 同或 B = (A   ^   B)再按位取反

public static int sameOr(int a, int b) {
        return ~(a ^ b);
    }

6.左移（<<）

<< ： 在一定范围内，每向左移 1 位，就相当于 * 2；

举例: 3 << 5

3 => 0000 0000 0000 0011

<<    0000 0000 0110 0000  转换成十进制也就是 96 = 3  *  (2^5) (这里的^代表几次方 不是异或)

面试题：最高效的计算 2 * 8？ 

2 << 3  结果 16

8 << 1 结果 16

通过位运算 效率是最高效的

7.右移（>>）

>> : 在一定范围内，每向右移 1 位，就相当于 / 2；

举例: 96 >> 5

96 => 0000 0000 0110 0000

<<      0000 0000 0000 0011  转换成十进制也就是 3 = 96  /  (2^5)