位运算及其应用场景

概念理解
  • 按位与 & :全1为1,有0为0

假设 1:true,0:false,联想Java中的&&运算符,只有两个都为true才为true,其他均为false
&举例:
0000 0011
0000 1010
==============
0000 0010

  • 按位或 | :有1为1,全0为0

假设 1:true,0:false,联想Java中的||运算符,只有有一个为为true就为true,全为false才为false
| 举例:
0000 0011
0000 1010
==============
0000 1011

  • 按位异或 ^ :不同为1,相同为0

假设1为男性,0为女性,异性相吸修成正果则为1,同性相斥孤独终老为0
^ 举例:
0000 0011
0000 1010
==============
0000 1001

按位非:~ :按位取反,1为0,0为1

~ 举例:
0000 0011 ~
==============
1111 1100

  • 有符号左移 << :各二进位全部左移若干位,高位丢弃,低位补0
    若左移时舍弃的高位不包含1,则每左移一位,相当于该数乘以2
    a = a << 2 = a + 2的2次方

举例:
0000 1101 =
<< 2位
====================
0011 0100

  • 有符号右移 >> :将一个数的各二进制位全部右移若干位,正数左补0,负数左补1,右边丢弃。
    操作数每右移一位,相当于该数除以2。
    a = a >> 2 相当于 a除以2的2次方

举例:
0000 1101 =
>> 2位
====================
0000 0011 = 3

  • 无符号右移 >>> :将一个数的各二进制位全部右移若干位,高位补0
// 1010
System.out.println("10 = " + Integer.toBinaryString(10));

// 0110
System.out.println("6 = " + Integer.toBinaryString(6));

// 按位与: 1&1=1 1&0 = 0 0&1=0 0&0=0
// 0010
System.out.println("10 & 6 = " + Integer.toBinaryString(10 & 6));

// 按位或:1&1=1 1&0=1 0&1=1 0&0=0
// 1110
System.out.println("10 | 6 = " + Integer.toBinaryString(10 | 6));

// 按为异或:1&1=0 1&0=1 0&1=1 0&0=0
// 1100
System.out.println("10 ^ 6 = " + Integer.toBinaryString(10 ^ 6));


// 左移
int a = 10;
// 1010 <<2 = 0010 1000
// 40 = 10 * 2 ^ 2
System.out.println("a << 2 = " + (a << 2));
// 0010 1000
System.out.println("a << 2 = " + Integer.toBinaryString((a << 2)));

// 右移
int b = 101;
// 0110 0101
System.out.println("b = " + Integer.toBinaryString(101));
// 101 / 2^2 = 25
System.out.println("b >> 2 = " + (b >> 2));
// 0001 1001
System.out.println("b >> 2 = " + Integer.toBinaryString((b >> 2)));
应用场景

1、取模

当一个数a除以 2的n次方求余数时,(a / 2^n)等价于 a & (2^n - 1)
原理:某个数A,对 2^n 取模,则余数最大值为 2^n-1 ,当按位与上 2^n-1 时,高位的都被舍弃,只留下了2^n-1中满足条件的余数

/**
 * 如果取模的分母是2的N次方,则等价于 &上2的N次方-1
 * b % 4 = b & (2 ^2 - 1)
 * b = 101
 *   0110 0101
 * & 0000 0011
 * ---------------
 *   0000 0001
 *
 *   b = 111 % 16 = 15
 *
 *   0110 1111
 *   0000 1111
 *   ------------
 *   0000 1111
 *
 */
// 1
int b = 101;
System.out.println("b % 4 = " + (b % 4) + " = " + (b & (4 - 1)));
b = 111;
// 15
System.out.println("b % 16 = " + (b % 16) + " = " + (b & (16 - 1)));

2、保存操作状态或商品属性开关

权限控制,有增删改查四种权限,传统意义上会在新增四个属性分别对应四种权限,如果有再新增权限的话,又要新增属性
在这种情况下,可以使用位,一个int类型有32位,理论上可以存储32个属性、状态

/**
 * 权限操作类
 */
public class Permissions {

    /**
     * 二进制第1位是否允许查询,0表示否,1表示是
     * 1 << 0 = 0001  = 1
     */
    public static final int ALLOW_SELECT = 1 << 0;

    /**
     * 二进制第2位是否允许新增,0表示否,1表示是
     * 1 << 1 = 0010  = 2
     */
    public static final int ALLOW_INSERT = 1 << 1;

    /**
     * 二进制第3位是否允许修改,0表示否,1表示是
     * 1 << 2 = 0100 = 4
     */
    public static final int ALLOW_UPDATE = 1 << 2;

    /**
     * 二进制第4位是否允许删除,0表示否,1表示是
     * 1 << 3 = 1000 = 8
     */
    public static final int ALLOW_DELETE = 1 << 3;


    /**
     * 目前所拥有的权限状态
     */
    private int flag;

    public int getFlag() {
        return flag;
    }

    public void setFlag(int flag) {
        this.flag = flag;
    }

    /**
     * 新增1个或者多个权限
     * 按位或,有1为1,全0为0,按位或后有1的位置全都有了权限
     */
    public void addPermission(int flag) {
        this.flag = this.flag | flag;
    }

    /**
     * 删除1个或多个权限
     * 先按位取反,这样不需要删除的位置为1,删除的位置为0,在按位与,将对于为0的位置置0
     *
     */
    public void removePermission(int flag) {
        this.flag = this.flag & ~flag;
    }

    /**
     * 是否有某个操作的权限
     * 先按位与后如果操作位对应的是1,则操作位继续为1,否则全为0,得到的结果要么为flag,要么全为0
     */
    public boolean hasPermission(int flag) {
        return (this.flag & flag) == flag;
    }

    public boolean hasNotPermission(int flag) {
        return (this.flag & flag) == 0;
    }

    /**
     * flag : 0, insert : false
     * flag : 0, delete : false
     * flag : 0, update : false
     * flag : 0, select : false
     * 添加查询权限
     * flag : 1, insert : false
     * flag : 1, delete : false
     * flag : 1, update : false
     * flag : 1, select : true
     * 添加修改权限
     * flag : 5, insert : false
     * flag : 5, delete : false
     * flag : 5, update : true
     * flag : 5, select : true
     * 添加删除权限
     * flag : 13, insert : false
     * flag : 13, delete : true
     * flag : 13, update : true
     * flag : 13, select : true
     * 添加插入权限
     * flag : 15, insert : true
     * flag : 15, delete : true
     * flag : 15, update : true
     * flag : 15, select : true
     * 去掉查询权限
     * flag : 14, insert : true
     * flag : 14, delete : true
     * flag : 14, update : true
     * flag : 14, select : false
     * 去掉修改权限
     * flag : 10, insert : true
     * flag : 10, delete : true
     * flag : 10, update : false
     * flag : 10, select : false
     * 去掉删除权限
     * flag : 2, insert : true
     * flag : 2, delete : false
     * flag : 2, update : false
     * flag : 2, select : false
     * 去掉插入权限
     * flag : 0, insert : false
     * flag : 0, delete : false
     * flag : 0, update : false
     * flag : 0, select : false
     */
    public static void main(String[] args) {
        // 默认没有任何权限
        int flag = 0;
        Permissions permissions = new Permissions();
        permissions.setFlag(flag);
        permissions.print(permissions);
        // 添加查询权限
        System.out.println("添加查询权限");
        permissions.addPermission(Permissions.ALLOW_SELECT);
        permissions.print(permissions);
        // 添加修改权限
        System.out.println("添加修改权限");
        permissions.addPermission(Permissions.ALLOW_UPDATE);
        permissions.print(permissions);
        // 添加删除权限
        System.out.println("添加删除权限");
        permissions.addPermission(Permissions.ALLOW_DELETE);
        permissions.print(permissions);
        // 添加插入权限
        System.out.println("添加插入权限");
        permissions.addPermission(Permissions.ALLOW_INSERT);
        permissions.print(permissions);

        // 去掉查询权限
        System.out.println("去掉查询权限");
        permissions.removePermission(Permissions.ALLOW_SELECT);
        permissions.print(permissions);

        // 去掉修改权限
        System.out.println("去掉修改权限");
        permissions.removePermission(Permissions.ALLOW_UPDATE);
        permissions.print(permissions);

        // 去掉删除权限
        System.out.println("去掉删除权限");
        permissions.removePermission(Permissions.ALLOW_DELETE);
        permissions.print(permissions);

        // 去掉插入权限
        System.out.println("去掉插入权限");
        permissions.removePermission(Permissions.ALLOW_INSERT);
        permissions.print(permissions);
    }

    private void print(Permissions permissions) {
        System.out.println("flag : " + permissions.getFlag() + ", insert : " + permissions.hasPermission(Permissions.ALLOW_INSERT));
        System.out.println("flag : " + permissions.getFlag() + ", delete : " + permissions.hasPermission(Permissions.ALLOW_DELETE));
        System.out.println("flag : " + permissions.getFlag() + ", update : " + permissions.hasPermission(Permissions.ALLOW_UPDATE));
        System.out.println("flag : " + permissions.getFlag() + ", select : " + permissions.hasPermission(Permissions.ALLOW_SELECT));
    }

}

推荐阅读更多精彩内容