• Java位运算在程序设计中的使用：位掩码（BitMask）

    在Java中，位运算符有很多，例如与(&)、非(~)、或(|)、异或(^)、移位(<<和>>)等。这些运算符在日常编码中很少会用到。

    在下面的一个例子中，会用到位掩码（BitMask），其中包含大量的位运算。不只是在Java中，其他编写语言中也是可以使用的。

    例如，在一个系统中，用户一般有查询(Select)、新增(Insert)、修改(Update)、删除(Selete)四种权限，四种权限有多种组合方式，也就是有16中不同的权限状态（2的4次方）。

    一般情况下会想到用四个boolean类型变量来保存：

    Permission.java

    [java] view plaincopy
     
    1. public class Permission {  
    2.       
    3.     // 是否允许查询  
    4.     private boolean allowSelect;  
    5.       
    6.     // 是否允许新增  
    7.     private boolean allowInsert;  
    8.       
    9.     // 是否允许删除  
    10.     private boolean allowDelete;  
    11.       
    12.     // 是否允许更新  
    13.     private boolean allowUpdate;  
    14.   
    15.     public boolean isAllowSelect() {  
    16.         return allowSelect;  
    17.     }  
    18.   
    19.     public void setAllowSelect(boolean allowSelect) {  
    20.         this.allowSelect = allowSelect;  
    21.     }  
    22.   
    23.     public boolean isAllowInsert() {  
    24.         return allowInsert;  
    25.     }  
    26.   
    27.     public void setAllowInsert(boolean allowInsert) {  
    28.         this.allowInsert = allowInsert;  
    29.     }  
    30.   
    31.     public boolean isAllowDelete() {  
    32.         return allowDelete;  
    33.     }  
    34.   
    35.     public void setAllowDelete(boolean allowDelete) {  
    36.         this.allowDelete = allowDelete;  
    37.     }  
    38.   
    39.     public boolean isAllowUpdate() {  
    40.         return allowUpdate;  
    41.     }  
    42.   
    43.     public void setAllowUpdate(boolean allowUpdate) {  
    44.         this.allowUpdate = allowUpdate;  
    45.     }  
    46. }  


    上面用四个boolean类型变量来保存每种权限状态。下面是另外一种方式，使用位掩码的话，用一个二进制数即可，每一位来表示一种权限，0表示无权限，1表示有权限。

    NewPermission.java

    [java] view plaincopy
     
    1. public class NewPermission {  
    2.     // 是否允许查询，二进制第1位，0表示否，1表示是  
    3.     public static final int ALLOW_SELECT = 1 << 0; // 0001  
    4.       
    5.     // 是否允许新增，二进制第2位，0表示否，1表示是  
    6.     public static final int ALLOW_INSERT = 1 << 1; // 0010  
    7.       
    8.     // 是否允许修改，二进制第3位，0表示否，1表示是  
    9.     public static final int ALLOW_UPDATE = 1 << 2; // 0100  
    10.       
    11.     // 是否允许删除，二进制第4位，0表示否，1表示是  
    12.     public static final int ALLOW_DELETE = 1 << 3; // 1000  
    13.       
    14.     // 存储目前的权限状态  
    15.     private int flag;  
    16.   
    17.     /** 
    18.      *  重新设置权限 
    19.      */  
    20.     public void setPermission(int permission) {  
    21.         flag = permission;  
    22.     }  
    23.   
    24.     /** 
    25.      *  添加一项或多项权限 
    26.      */  
    27.     public void enable(int permission) {  
    28.         flag |= permission;  
    29.     }  
    30.       
    31.     /** 
    32.      *  删除一项或多项权限 
    33.      */  
    34.     public void disable(int permission) {  
    35.         flag &= ~permission;  
    36.     }  
    37.       
    38.     /** 
    39.      *  是否拥某些权限 
    40.      */  
    41.     public boolean isAllow(int permission) {  
    42.         return (flag & permission) == permission;  
    43.     }  
    44.       
    45.     /** 
    46.      *  是否禁用了某些权限 
    47.      */  
    48.     public boolean isNotAllow(int permission) {  
    49.         return (flag & permission) == 0;  
    50.     }  
    51.       
    52.     /** 
    53.      *  是否仅仅拥有某些权限 
    54.      */  
    55.     public boolean isOnlyAllow(int permission) {  
    56.         return flag == permission;  
    57.     }  
    58. }  


    NewPermission代码中，用四个常量表示了每个二进制位代码的权限项。
    例如：
    ALLOW_SELECT = 1 << 0 转成二进制就是0001，二进制第一位表示Select权限，
    ALLOW_INSERT = 1 << 1 转成二进制就是0010，二进制第二位表示Insert权限
    ......

    private int flag存储了各种权限的启用和停用状态，相当于代替了Permission中的四个boolean类型的变量。
    用flag的四个二进制位来表示四种权限的状态，每一位的0和1代表一项权限的启用和停用：

    flag 删除 修改 新增 查询  
    1(0001) 0 0 0 1 只允许查询（即等于ALLOW_SELECT）
    2(0010) 0 0 1 0 只允许新增（即等于ALLOW_INSERT）
    4(0100) 0 1 0 0 只允许修改（即等于ALLOW_UPDATE）
    8(1000) 1 0 0 0 只允许删除（即等于ALLOW_DELETE）
    3(0011) 0 0 1 1 只允许查询和新增
    0 0 0 0 0 四项权限都不允许
    15(1111) 1 1 1 1 四项权限都允许

    ...等等，不一一列举。
    使用位掩码的方式，只需要用一个大于或等于0且小于16的整数即可表示所有的16种权限的状态。

    此外，还有很多设置权限和判断权限的方法，用到了很多位运算，例如

    [java] view plaincopy
     
    1. public void enable(int permission) {  
    2.     flag |= permission; // 相当于flag = flag | permission;  
    3. }  


    这个方法是在现有的权限基础上添加一项或多项权限。
    添加一项Update权限：

    [java] view plaincopy
     
    1. permission.enable(NewPermission.ALLOW_UPDATE);  

    假设现有权限只有Select，也就是flag是0001。
    执行以上代码：
    flag = 0001 | 0100，也就是0101，便拥有了Select和Update两项权限。

    添加Insert、Update、Delete三项权限：

    [java] view plaincopy
     
    1. permission.enable(NewPermission.ALLOW_INSERT   
    2.     | NewPermission.ALLOW_UPDATE | NewPermission.ALLOW_DELETE);  

    NewPermission.ALLOW_INSERT | NewPermission.ALLOW_UPDATE | NewPermission.ALLOW_DELETE运算结果是1110。
    假设现有权限只有Select，也就是flag是0001。
    flag = 0001 | 1110，也就是1111，便拥有了这四项权限，相当于添加了三项权限。
    上面的设置如果使用Permission类的话，就需要下面三行代码：

    [java] view plaincopy
     
    1. permission.setAllowInsert(true);  
    2. permission.setAllowUpdate(true);  
    3. permission.setAllowDelete(true);  

    其他方法不再一一解释。

    下面对比Permission和NewPermission两种方式：

    1.设置仅允许Select和Insert权限

    Permission

    [java] view plaincopy
     
    1. permission.setAllowSelect(true);  
    2. permission.setAllowInsert(true);  
    3. permission.setAllowUpdate(false);  
    4. permission.setAllowDelete(false);  

    NewPermission

    [java] view plaincopy
     
    1. permission.setPermission(NewPermission.ALLOW_SELECT | NewPermission.ALLOW_INSERT);  

    2.判断是否允许Select和Insert、Update权限

    Permission

    [java] view plaincopy
     
    1. if (permission.isAllowSelect() && permission.isAllowInsert() && permission.isAllowUpdate())  

    NewPermission

    [java] view plaincopy
     
    1. if (permission. isAllow (NewPermission.ALLOW_SELECT   
    2.     | NewPermission.ALLOW_INSERT | NewPermission.ALLOW_UPDATE))  

    3.判断是只否允许Select和Insert权限

    Permission

    [java] view plaincopy
     
    1. if (permission.isAllowSelect() && permission.isAllowInsert()   
    2.     && !permission.isAllowUpdate() && !permission.isAllowDelete())  

    NewPermission

    [java] view plaincopy
     
    1. if (permission. isOnlyAllow (NewPermission.ALLOW_SELECT | NewPermission.ALLOW_INSERT))  

    二者对比可以感受到MyPermission位掩码方式相对于Permission的优势，可以节省很多代码量，位运算是底层运算，效率也非常高，而且理解起来也很简单。

    附：

    在Java反射中，java.lang.reflect.Modifier是用来判断类、成员变量、方法等包含的修饰符。在Modifier的源代码中可以看到：

    [java] view plaincopy
     
    1. public static final int PUBLIC           = 0x00000001;  
    2. public static final int PRIVATE          = 0x00000002;    
    3. public static final int PROTECTED        = 0x00000004;    
    4. public static final int STATIC           = 0x00000008;    
    5. public static final int FINAL            = 0x00000010;    
    6. public static final int SYNCHRONIZED     = 0x00000020;  
    7. // ......  
    8. public static boolean isProtected(int mod) {  
    9.     return (mod & PROTECTED) != 0;  
    10. }  
    11. public static boolean isStatic(int mod) {  
    12.     return (mod & STATIC) != 0;  
    13. }  

    这里使用二进制位来表示是否有某个修饰符。具体使用方式可以去看我的另一篇博文：Java反射之如何判断类或变量、方法的修饰符(Modifier解析)

    此外，在Android开发中，Linkify可以设置文本中的地址、电话、邮箱等是否支持点击链接：

    [java] view plaincopy
     
    1. Linkify.addLinks(textView, Linkify.WEB_URLS | Linkify.EMAIL_ADDRESSES);  


    android.text.util.Linkify部分源码：

    [java] view plaincopy
     
      1. public static final int WEB_URLS = 0x01;  
      2. public static final int EMAIL_ADDRESSES = 0x02;  
      3. public static final int PHONE_NUMBERS = 0x04;  
      4. public static final int MAP_ADDRESSES = 0x08;  
      5. public static final int ALL = WEB_URLS | EMAIL_ADDRESSES | PHONE_NUMBERS | MAP_ADDRESSES;  
      6.   
      7. public static final boolean addLinks(Spannable text, int mask) {  
      8.     if (mask == 0) {  
      9.         return false;  
      10.     }  
      11.   
      12.     URLSpan[] old = text.getSpans(0, text.length(), URLSpan.class);  
      13.   
      14.     for (int i = old.length - 1; i >= 0; i--) {  
      15.         text.removeSpan(old[i]);  
      16.     }  
      17.   
      18.     ArrayList<LinkSpec> links = new ArrayList<LinkSpec>();  
      19.   
      20.     if ((mask & WEB_URLS) != 0) {  
      21.         gatherLinks(links, text, Patterns.WEB_URL,  
      22.             new String[] { "http://", "https://", "rtsp://" },  
      23.             sUrlMatchFilter, null);  
      24.     }  
      25.   
      26.     if ((mask & EMAIL_ADDRESSES) != 0) {  
      27.         gatherLinks(links, text, Patterns.EMAIL_ADDRESS,  
      28.             new String[] { "mailto:" },  
      29.             null, null);  
      30.     }  
      31.   
      32.     if ((mask & PHONE_NUMBERS) != 0) {  
      33.         gatherLinks(links, text, Patterns.PHONE,  
      34.             new String[] { "tel:" },  
      35.             sPhoneNumberMatchFilter, sPhoneNumberTransformFilter);  
      36.     }  
      37.   
      38.     if ((mask & MAP_ADDRESSES) != 0) {  
      39.         gatherMapLinks(links, text);  
      40.     }  
      41.   
      42.     pruneOverlaps(links);  
      43.   
      44.     if (links.size() == 0) {  
      45.         return false;  
      46.     }  
      47.   
      48.     for (LinkSpec link: links) {  
      49.         applyLink(link.url, link.start, link.end, text);  
      50.     }  
      51.   
      52.     return true;  
      53. }  
  • 相关阅读:
    康威定律和系统设计——《微服务设计》读书笔记
    安全——《微服务设计》读书笔记
    监控——《微服务设计》读书笔记
    测试——《微服务设计》读书笔记
    [转]Linux 系统挂载数据盘
    部署:持续集成（CI）与持续交付（CD）——《微服务设计》读书笔记
    拆分:分解单块系统——《微服务设计》读书笔记
    Unused Method(不再使用的方法)——Dead Code（死亡代码）
    使用Fortify进行代码静态分析（系列文章）
    NEUACM1132: Renew MST Quickly 增量最小生成树
  • 原文地址：https://www.cnblogs.com/xiaorenwu702/p/4418656.html
Copyright © 2020-2023  润新知