概念理解
- 按位与 & ：全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));
}
}
