常见的位运算和算法总结

1
2
3
4
5
6
7
1 & 1 = 1
1 & 0 = 0
0 & 0 = 0
  
1110 & 0111 = 0101
  

1
2
3
4
5
6
7
1 | 1 = 1
1 | 0 = 1
0 | 0 = 0
  
1110 | 0111 = 1111
  

1
2
3
4
~1 = 0
~0 =1
~ 1110 = 0001

1
2
3
4
  0000 1111
^ 0000 1100
= 0000 0011

1
2
3
4
5
6
7
# 首先是是 3 
0000 0011
# 然后取反
1111 1100
# 然后 +1 
1111 1101

1
2
3
4
5
6
   00000000 00000000 00000000 00000011 #3，原码
+  xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx #-3，补码
-----------------------------------------------
 (1)00000000 00000000 00000000 00000000 #括号里面的 1 是忽略的溢出

1
2
3
4
5
   00000000 00000000 00000000 00000011 #3，原码                         
+  11111111 11111111 11111111 11111101 #-3，补码
-----------------------------------------------
 1 00000000 00000000 00000000 00000000

1
2
3
4
0000 0011
0000 0011
0000 0110

1
2
3
4
5
6
7
8
9
10
11
# 5
0000 0101
# -3
1111 1101
# 5 -3
# 这里注意多了一位，「我们直接忽略溢出」
# 这就是减法这么表示的原因
(1)0000 0010
# 最后 5-3 结果为
0000 0010

1
2
3
4
5
6
7
# 测试第一个数据 0001 1100 （第三位是 1)
  0000 1100 
& 0000 0100 #这里是关键，我们将 0000 0001 右移 3-1 = 2位 就是 0000 0100 ，
            # 用这个和测试数据取与 & 
= 0000 0100 
# 因为 0000 1100 & 0000 0100 == 0000 0100 可以判定，第三位是 1

1
2
3
4
5
6
7
# 测试第二个数据 0000 0010 (第三位不是 1)
  0000 0010 
& 0000 0100 #这里是关键，我们将 0000 0001 右移 3-1 = 2位 就是 0000 0100 ，
            #用这个和测试数据取与 & 
= 0000 0000
# 因为 0000 0010 & 0000 0100 != 0000 0100 可以判定，第三位不是 0

1
2
3
4
5
6
7
# 测试的第一个数据是 0000 0000 (我们要将它从右至左的第三个位置设置为 1)
  0000 0000 
| 0000 0100 #这里是关键，我们将 0000 0001 右移 3-1 = 2位 就是 0000 0100 ，
            # 用这个和测试数据取货 |
= 0000 0100 
# 我们使用取  | 或操作，成功，将第三为设置为 1 ，不管这个位置是 0 还是 1 都会被设置为 1

1
2
3
4
5
6
7
8
# 测试第一个数据 0001 1100 （第三位是 1，将其变为 0)
0000 0100 
& 1111 1011 # 这里十分关键，我们先将 0000 0001 左移 3-1=2 位为 0000 0100
            # 然后取反为 1111 1011
            # 然后再和元数据 0000 0100 & 运算
= 0000 0000 
# 成功

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class BitUtils {

    public static final byte base = 1;
    
    /**
     * 判断对于 aByte 来说index的位置是,是0或是1
     */
    public static boolean check(int index,byte aByte) {
        return(base << index) == (aByte & base << index);
    }

    /**
     * 将 index 的位置设置为 1
     */
    public static byte setTure(int index,byte aByte) {
        return (byte) (aByte | base<<index);
    }

    /**
     * 将 index 位置设置为 0
     */
    public static byte setFalse(int index, byte aByte) {
        //左移
        int temp1 = base << index;
        //取反
        int temp2 = ~temp1;
        return (byte) (aByte & temp2);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
    public static void main(String[] args) {
        //判断 0000 0001 第一个位置 是是否为 1
        System.out.println("判断 0000 0001 第一个位置 是是否为 1"+check(0, (byte) 1));
        //判断 0000 0010 第一个位置 是是否为 1
        System.out.println("判断 0000 0010 第一个位置 是是否为 1:"+check(0, (byte) 2));
        //将 0000 0000 第二个位置设置为 1
        byte b = setTure(1, (byte) 0);
        System.out.println("将 0000 0000 第二个位置设置为 1:"+b);
        //将 0000 0010 第二个位置设置为0
        byte b2 = setFalse(1, (byte) 2);
        System.out.println("将 0000 0010 第二个位置设置为 0:"+b2);
    }