精华内容
下载资源
问答
  • 二进制的运算:遇1得1 参加运算的两个对象,按二进制位进行“运算运算规则:0|0=0; 0|1=1; 1|0=1; 1|1=1; 参加运算的两个对象只要有一个为1,其值为1。 例如:3|5 0000 0011 0000 0101 0000 0111 ...

    #####二进制算法

    • 二进制的【或】运算:遇1得1 参加运算的两个对象,按二进制位进行“或”运算。 运算规则:0|0=0; 0|1=1; 1|0=1; 1|1=1; 参加运算的两个对象只要有一个为1,其值为1。 例如:3|5  0000 0011 0000 0101 0000 0111

    • 二进制的【与】运算:遇0得0 运算规则:0&0=0; 0&1=0; 1&0=0; 1&1=1; 即:两位同时为“1”,结果才为“1”,否则为0 例如:3&5 0000 0011
      0000 0101 0000 0001

    • 二进制的【非】运算:各位取反 运算规则:~1=0; ~0=1; 对一个二进制数按位取反,即将0变1,1变0。

    • 二进制的【异或】运算符 “^”:相同为0 ,不同为1” 参加运算的两个数据,按二进制位进行“异或”运算。 运算规则:0^0=0; 0^1=1; 1^0=1; 1^1=0; 参加运算的两个对象,如果两个相应位为“异”(值不同),则该位结果为1,否则为0。

    • ######看我那么可爱n(≧▽≦)n

    • 关注我的微薄 (梁同桌):http://weibo.com/tongrenyinsheng

    • 个人博客: www.liangtongzhuo.com

    • ios 个人写的app (同人音声)ASMR音乐

    转载于:https://juejin.im/post/5a31f12df265da43112038d1

     
    展开全文
  • 二进制的与非运算特殊用法的不同运用场合: 1.权限控制  下面我用几个数字来代表增,删,改,查。(注:1带有有权限,有几个1,就代表有几个权限,1的位置不同,所带表的权限也不同) Java代码 ...
    二进制的与、或、非运算特殊用法的不同运用场合:
    1.权限控制
        下面我用几个数字来代表增,删,改,查。(注:1带有有权限,有几个1,就代表有几个权限,1的位置不同,所带表的权限也不同)
    Java代码  收藏代码
    1. 1---------增--------(转二进制)-----(0001)  
    2. 2---------删----------------------(0010)  
    3. 4--------改----------------------(0100)  
    4. 8--------查----------------------(1000)  


    管理员拥有所有的权限,所以,控制管理员的权限的数字为(15),转化二进制的格式为:(1111)。算法为:“1|2|4|8“
    撤销管理员的删权限(2),控制管理员的权限的数字为(13),转化二进制的格式为:(1101)。算法为:”15 & (~2)”
    判断管理员的权限中是否有某个权限。如在控制管理员的权限的数字为(13)时,判断管理员是否具有修改的权限(4)。算法为:“13 & 4==0”,假如等于0的话,表示,权限不存在,假如不等于0的话,表示,此权限已经存在。


    2.分类组合
       假如一个类要支持很多操作,操作和操作之间可能没有联系,可能有相反关系无法共存,可能有特殊关系必须共存,这种要分很多类还要处理联系的情况下可以考虑采用二进制来解决。
        我这里的例子是java做的文件搜索,用的是递归,搜索的时候可以搜索文件、文件夹,搜索的方式可以有正则表达式匹配、以特定开始、以特定结束、以是否包含的方式。而且除了正则则要单独处理,其他方式直接可以进行组合。
        通过二进制分类

    Java代码  收藏代码
    1. /** 查找文件夹 */  
    2. public static final int      FIND_DIRECTORY  = 1;  
    3. /** 查找文件 */  
    4. public static final int      FIND_FILE       = 2;  
    5. /** 正则查找 */  
    6. public static final int      FIND_BY_REGEX   = 4;  
    7. /** 起始于 */  
    8. public static final int      FIND_START_WITH = 8;  
    9. /** 结束于 */  
    10. public static final int      FIND_END_WITH   = 16;  
    11. /** 包含于 */  
    12. public static final int      FIND_CONTAIN    = 32;  
    13. // rule  
    14. private int           _rule        = 0;  

        当程序传入规则之后,我可以很方便的加入到 _rule中
    Java代码  收藏代码
    1. /** 添加规则 */  
    2. public int ruleAdd(int r) {  
    3.   
    4.   _rule = _rule | r;  
    5.   return _rule;  
    6. }  

         去除 和 判断是否有这个规则

    Java代码  收藏代码
    1. /** 去除规则 */  
    2. public int ruleRemove(int r) {  
    3.   
    4.   _rule = _rule & (~r);  
    5.   return _rule;  
    6. }  
    7.   
    8. /** 是否包含规则 */  
    9. public Boolean hasRule(int r) {  
    10.   
    11.   return (_rule & r) != 0;  
    12. }  

        之后处理时进行 if分类 就可以很方便
    Java代码  收藏代码
    1. /** 
    2.     * 判断是否满足规则用户指定的rule (正则表达式 ______ 开始于 __________ 结束于) 
    3.     * 
    4.     * @param content 
    5.     * @return 
    6.     */  
    7.    public Boolean meetRule(File pathname) {  
    8.   
    9.      Boolean result = true;  
    10.      // 查找路径  
    11.      if (hasRule(FIND_DIRECTORY)) {  
    12.          result = result && pathname.isDirectory();  
    13.      }  
    14.      // 查找文件  
    15.      if (hasRule(FIND_FILE)) {  
    16.          result = result && pathname.isFile();  
    17.      }  
    18.      String fileName = pathname.getName().toUpperCase();  
    19.      // 按照开始于查找  
    20.      if (hasRule(FIND_START_WITH)) {  
    21.          result = result && fileName.startsWith(_fix.get(FIND_START_WITH).toUpperCase());  
    22.      }  
    23.      // 按照结束于查找  
    24.      if (hasRule(FIND_END_WITH)) {  
    25.          result = result && fileName.endsWith(_fix.get(FIND_END_WITH).toUpperCase());  
    26.      }  
    27.      // 文件名包含查找  
    28.      if (hasRule(FIND_CONTAIN)) {  
    29.          result = result && fileName.contains(_fix.get(FIND_CONTAIN).toUpperCase());  
    30.      }  
    31.      // 按照正则查找 不区分大小写  
    32.      if (_rule == FIND_BY_REGEX) {  
    33.          result = result && Pattern.compile(_fix.get(FIND_BY_REGEX), Pattern.CASE_INSENSITIVE).matcher(fileName).find();  
    34.      }  
    35.      return result;  
    36.    }  


    大体就是这个个意思,完整代码
    Java代码  收藏代码
    1. /** 
    2.  * 查找指定路径下 满足条件的文件、文件夹(不区分大小写) 
    3.  * 
    4.  * @see 
    5.  * @author kaven 
    6.  * @version 1.0, 2011-8-27 
    7.  * @since 1.0, 2011-8-27 
    8.  */  
    9. public class PathSearch {  
    10.   
    11.     /** 查找文件夹 */  
    12.     public static final int      FIND_DIRECTORY  = 1;  
    13.     /** 查找文件 */  
    14.     public static final int      FIND_FILE       = 2;  
    15.     /** 正则查找 */  
    16.     public static final int      FIND_BY_REGEX   = 4;  
    17.     /** 起始于 */  
    18.     public static final int      FIND_START_WITH = 8;  
    19.     /** 结束于 */  
    20.     public static final int      FIND_END_WITH   = 16;  
    21.     /** 包含于 */  
    22.     public static final int      FIND_CONTAIN    = 32;  
    23.   
    24.     // rule  
    25.     private int           _rule        = 0;  
    26.     // 用户输入的用来匹配文件名的字段 或者正则  
    27.     private Map<Integer, String> _fix         = new HashMap<Integer, String>();  
    28.     // 文件  
    29.     private List<File>     _files = new ArrayList<File>();  
    30.   
    31.     public PathSearch() {  
    32.   
    33.     }  
    34.   
    35.     // public PathSearch(Map<Integer, String> aFix) {  
    36.     //  
    37.     // this._fix = aFix;  
    38.     // }  
    39.   
    40.     /** 添加规则 */  
    41.     public int ruleAdd(int r) {  
    42.   
    43.       _rule = _rule | r;  
    44.       return _rule;  
    45.     }  
    46.   
    47.     /** 去除规则 */  
    48.     public int ruleRemove(int r) {  
    49.   
    50.       _rule = _rule & (~r);  
    51.       return _rule;  
    52.     }  
    53.   
    54.     /** 是否包含规则 */  
    55.     public Boolean hasRule(int r) {  
    56.   
    57.       return (_rule & r) != 0;  
    58.     }  
    59.   
    60.     /** 
    61.      * 判断是否满足规则用户指定的rule (正则表达式 ______ 开始于 __________ 结束于) 
    62.      * 
    63.      * @param content 
    64.      * @return 
    65.      */  
    66.     public Boolean meetRule(File pathname) {  
    67.   
    68.       Boolean result = true;  
    69.       // 查找路径  
    70.       if (hasRule(FIND_DIRECTORY)) {  
    71.           result = result && pathname.isDirectory();  
    72.       }  
    73.       // 查找文件  
    74.       if (hasRule(FIND_FILE)) {  
    75.           result = result && pathname.isFile();  
    76.       }  
    77.       String fileName = pathname.getName().toUpperCase();  
    78.       // 按照开始于查找  
    79.       if (hasRule(FIND_START_WITH)) {  
    80.           result = result && fileName.startsWith(_fix.get(FIND_START_WITH).toUpperCase());  
    81.       }  
    82.       // 按照结束于查找  
    83.       if (hasRule(FIND_END_WITH)) {  
    84.           result = result && fileName.endsWith(_fix.get(FIND_END_WITH).toUpperCase());  
    85.       }  
    86.       // 文件名包含查找  
    87.       if (hasRule(FIND_CONTAIN)) {  
    88.           result = result && fileName.contains(_fix.get(FIND_CONTAIN).toUpperCase());  
    89.       }  
    90.       // 按照正则查找 不区分大小写  
    91.       if (_rule == FIND_BY_REGEX) {  
    92.           result = result && Pattern.compile(_fix.get(FIND_BY_REGEX), Pattern.CASE_INSENSITIVE).matcher(fileName).find();  
    93.       }  
    94.       return result;  
    95.     }  
    96.   
    97.     /** 
    98.      * 添加规则(等价于 ruleAdd) 
    99.      * 
    100.      * @param rule 
    101.      */  
    102.     public void addRule(int rule) {  
    103.   
    104.       ruleAdd(rule);  
    105.     }  
    106.   
    107.     /** 
    108.      * 添加规则 和 规则验证字段 
    109.      * 
    110.      * @param rule 
    111.      * @param value 
    112.      */  
    113.     public void addRule(int rule, String value) {  
    114.   
    115.       ruleAdd(rule);  
    116.       this._fix.put(rule, value);  
    117.     }  
    118.   
    119.     /** 
    120.      * 根据给定的path 查找其下满足特定条件的文件、文件夹 
    121.      */  
    122.     public void findUnderPath(String path) {  
    123.   
    124.       File directory = new File(path);  
    125.       if (!directory.exists()) {  
    126.           // 路径不存在  
    127.           return;  
    128.       }  
    129.       File[] files = directory.listFiles(new FileFilter() {  
    130.   
    131.           @Override  
    132.           public boolean accept(File pathname) {  
    133.   
    134.             return meetRule(pathname);  
    135.           }  
    136.       });  
    137.       _files = Arrays.asList(files);  
    138.     }  
    139.   
    140.     /** 
    141.      * 根据指定的path 查找其下包括子文件夹 所有满足特定条件的文件、文件夹 
    142.      * 
    143.      * @return 
    144.      */  
    145.     public void findDeepUnderPath(File pathName) {  
    146.   
    147.       if (!pathName.exists()) {  
    148.           return;  
    149.       }  
    150.       // 获取所有 符合规则的文件 列表  
    151.       File[] files = pathName.listFiles(new FileFilter() {  
    152.   
    153.           @Override  
    154.           public boolean accept(File pathname) {  
    155.   
    156.             return meetRule(pathname);  
    157.           }  
    158.       });  
    159.       // 添加到结果集列表中  
    160.       _files.addAll(Arrays.asList(files));  
    161.       // 查找所有目录  
    162.       File[] directories = pathName.listFiles(new FileFilter() {  
    163.   
    164.           @Override  
    165.           public boolean accept(File pathname) {  
    166.   
    167.             return pathname.isDirectory();  
    168.           }  
    169.       });  
    170.       // 获取子文件夹下的文件  
    171.       for (File directory : directories) {  
    172.           findDeepUnderPath(directory);  
    173.       }  
    174.     }  
    175.   
    176.     public List<File> getFiles() {  
    177.   
    178.       return _files;  
    179.     }  
    180.   
    181.     @Test  
    182.     public void testFind() {  
    183.   
    184.       String path = "F:\\work_tools";  
    185.       PathSearch ps = new PathSearch();  
    186.   
    187.       // ps.addRule(FIND_FILE);  
    188.       ps.addRule(FIND_BY_REGEX, "[\\d]");  
    189. //     ps.addRule(FIND_END_WITH, "rar");  
    190.   
    191.       // ps.findUnderPath(path);  
    192.       ps.findDeepUnderPath(new File(path));  
    193.       List<File> files = ps.getFiles();  
    194.       for (File f : files) {  
    195.           System.out.println(f.getPath());  
    196.       }  
    197.     }  
    198.   
    199. //    @Test  
    200.     public void testRule() {  
    201.   
    202.       System.out.println(ruleAdd(1));  
    203.       System.out.println(ruleAdd(4));  
    204.       System.out.println(ruleAdd(8));  
    205.       System.out.println(hasRule(4));  
    206.       System.out.println(ruleRemove(4));  
    207.       System.out.println(hasRule(4));  
    208.     }  
    209. }  

    3.快速找出两个list(或数组)中不同的对象
        一般的想法都是通过对两个list进行 循环嵌套,每找到一个,remove一个,这样的话有两个缺点:一个是速度,在最差的情况下是O(n^2),这对于数量大的是比较慢的。二是由于要remove元素,不能采用iterator尽心循环(据说采用迭代器java会有缓存优化)。
          这个就可以采用二进制来解决,其实这里用二进制只是一种方式,完全可以用 权的概念,一个权设为10,一个权设为1
    任意两个不相等的数都可以,如果多个list和数组的话,还是二进制方式比较清楚)。假如数组种的对象通过code来进行标示,新建一个
    Java代码  收藏代码
    1. Map<String,Integer> countMap = new HashMap<String,Integer>()//key -- > code, value -- > 权  

    分别对两个list进行第一次循环
       循环list1的时候:

    Java代码  收藏代码
    1. countMap.put(code,10);  

        循环list2的时候:

    Java代码  收藏代码
    1. if(null == countMap.get(code)){  
    2.    countMap.put(code, 0);//初始化为0  
    3. }  
    4. int count = countMap.get(code);//获取当前权  
    5. countMap.put(code, count + 1);//更新权  


    这样一来,所有list1独有的,countMap表现为Value为1,list2独有的,countMap表现为Value为10,共有的表现为Value为11
    然后进行第二次循环,将list1、list2根据code进行分类,组合成两个HashMap,以方便根据code找出code相同的部分(code相同不代表其他属性也相同,实际处理中可能会有用,不管你用没用到,反正我用到了)和code不同的部分。

    之后就是 根据找出来的code,各自的map中获取对应的对象了。
    复制度O(2n)
    我能想到的是这个方法,不知道有没有更好的,望提示!!!
    上代码:

    Java代码  收藏代码
    1. /** 
    2.  * 通过3次循环,对field 进行快速分类,找出彼此code不同的TableField 
    3.  * @author qihuan 
    4.  * 
    5.  */  
    6. public class QuickDiff {  
    7.     private List<TableField> oldFieldPop = new ArrayList<TableField>();  
    8.     private List<TableField> newFieldAppend = new ArrayList<TableField>();  
    9.     private List<String> commonCode = new ArrayList<String>();  
    10.     private Map<String, TableField> newFieldMap;  
    11.     private Map<String, TableField> oldFieldMap;  
    12.       
    13.     public QuickDiff(){  
    14.     }  
    15.     /** 
    16.      * 通过3次循环,对field 进行快速分类 
    17.      * @param oldFields 
    18.      * @param newFields 
    19.      */  
    20.     public void doDiff(List<TableField> oldFields,List<TableField> newFields){  
    21.     // key:desc -- value:对应出现次数  
    22.     Map<String,Integer> countMap = new HashMap<String, Integer>();  
    23.     addToMap(countMap,oldFields,1);//old 权为 1  
    24.     addToMap(countMap,newFields,10);//new 权为10  
    25.       
    26.     newFieldMap = turnToMapByCode(newFields);  
    27.     oldFieldMap = turnToMapByCode(oldFields);  
    28.     //对 独有的code进行分类  
    29.     for(String code : countMap.keySet()){  
    30.         int value = countMap.get(code);  
    31.         if(value == 11){  
    32.         commonCode.add(code);  
    33.         //do nothing  
    34.         }else if(value == 10){  
    35.         newFieldAppend.add(newFieldMap.get(code));  
    36.         }else if(value == 1){  
    37.         oldFieldPop.add(oldFieldMap.get(code));  
    38.         }  
    39.     }  
    40.     }  
    41.       
    42.     /** 
    43.      * 按照 code 进行分类 
    44.      * @param fields 
    45.      * @return 
    46.      */  
    47.     private Map<String, TableField> turnToMapByCode(List<TableField> fields){  
    48.     Map<String, TableField> fieldMap = new HashMap<String, TableField>();  
    49.     for(TableField tf : fields){  
    50.         String code = tf.getCode();  
    51.         fieldMap.put(code, tf);  
    52.     }  
    53.     return fieldMap;  
    54.     }  
    55.     /** 
    56.      *  
    57.      * @param countMap 计数map 
    58.      * @param fields  
    59.      * @param value 权 
    60.      */  
    61.     private void addToMap(Map<String, Integer> countMap, List<TableField> fields, int value) {  
    62.     for(TableField tf : fields){  
    63.         String code = tf.getCode();  
    64.         if(null == countMap.get(code)){  
    65.         countMap.put(code, 0);  
    66.         }  
    67.         int count = countMap.get(code);//获取当前权  
    68.         countMap.put(code, count + value);//更新权  
    69.     }  
    70.     }  
    71.     /** 
    72.      * old 独有的 
    73.      * @return 
    74.      */  
    75.     public List<TableField> getOldFieldPop() {  
    76.       
    77.         return oldFieldPop;  
    78.     }  
    79.     /** 
    80.      * new 独有的 
    81.      * @return 
    82.      */  
    83.     public List<TableField> getNewFieldAppend() {  
    84.       
    85.         return newFieldAppend;  
    86.     }  
    87.     /** 
    88.      * 共有的 
    89.      * @return 
    90.      */  
    91.     public List<String> getCommonCode() {  
    92.       
    93.         return commonCode;  
    94.     }  
    95.     /** 
    96.      * newField to Map 
    97.      * @return 
    98.      */  
    99.     public Map<String, TableField> getNewFieldMap() {  
    100.       
    101.         return newFieldMap;  
    102.     }  
    103.     /** 
    104.      * oldField to Map 
    105.      * @return 
    106.      */  
    107.     public Map<String, TableField> getOldFieldMap() {  
    108.       
    109.         return oldFieldMap;  
    110.     }  
    111.       

    展开全文
  • 文章目录1.二进制1.1.原码1.2.反码1.3.补码2.八进制3.十六进制4.位运算4.1.(&)运算4.2.(|)运算4.3.(~)运算4.4....二进制,是计算技术中广泛采用一种数制,二进制数据是用0和1...

    1.二进制

    二进制,是计算技术中广泛采用的一种数制,二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”。

    二进制的最高位是符号位,0是正数,1是负数,所以8位二进制的取值范围用二进制表示是[11111111,01111111],用十进制表示是[-128,127],二进制中约定正数的原码反码补码相同
    java中二进制表示为0b开头,如

        int b = 0b00010001;//对应十进制为2的4次方+2的0次方=17
    

    8位最大的二进制有符号数对应的十进制计算规则如下:
    在这里插入图片描述
    再举个例子,将0b00010101转换为十进制,计算规则如下:

    0b00010101 => 24 +22 +20 = 16 + 4 + 1 = 21

    1.1.原码

    原码即二进制本身

    1.2.反码

    正数的反码与原码相同;
        如:00001000 反码为 00001000
    负数保持符号位为1,其他位按位取反得到的即是负数的反码;
        如:10001000 反码为 11110111

    1.3.补码

    正数的补码与原码、反码相同;
        如:00001000 补码为 00001000
    负数的补码为反码+1
        如:10001000 反码为 11110111 ,则它的补码为 1 111 0111 +0 000 0001 = 1 1111000,即它的补码为11111000

    1.4.浮点数的二进制与十进制转换

    • 二进制转十进制

    0101.011 ==> 1=0*23 + 1*22 + 0*21 + 1*20 + 0*1/21 + 1*1/22 + 1*1/23 ==> 5.375

    • 十进制转二进制

    整数部分采用"除2取余,逆序排列"法。具体做法是:用2整除十进制整数,可以得到一个商和余数;再用2去除商,又会得到一个商和余数,如此进行,直到商为小于1时为止,然后把先得到的余数作为二进制数的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来。
    小数部分采用"乘2取整,顺序排列"法。具体做法是:用2乘十进制小数,可以得到积,将积的整数部分取出,再用2乘余下的小数部分,又得到一个积,再将积的整数部分取出,如此进行,直到积中的小数部分为零,此时0或1为二进制的最后一位。或者达到所要求的精度为止。

    如将6.125转换为二进制

    • 处理正数部分
      6/2=3 ----> 余0
      3/2=1----->余1
      1/2=0----->余1
      即正数部分为110
    • 处理小数部分
      0.1252=0.25 ----->整数位为0
      0.25
      2=0.5 ----->整数位为0
      0.5*2=1.0 ----->整数位为1
      即小数部分为001
      即最终结果为110.001

    2.八进制

    八进制的数据是用0,1,2,3,4,5,6,7来表示,它的基数是8,逢8进1。
    java中八进制表示为0开头,如:

       int c = 0023;//对应十进制为2*8的1次方+3*8的0次方=19
    

    4位最大的八进制数对应的十进制计算规则如下:
    在这里插入图片描述
    再举个例子,将0235转换为十进制,计算规则如下:

    0235=> 2*82 +3*81 +5*80 = 128 + 24 + 5 = 157

    3.十六进制

    十六进制的数据是用0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f来表示,它的基数为16,逢16进1。
    java中十六进制表示用0x开头,如:

        int d = 0x1ed;//对应16进制为1*16的2次方+14*16的1次方+15*16的0次方=493
    

    16进制基础值对应的十进制为:
    在这里插入图片描述
    4位最大的十六进制数对应的十进制计算规则如下:
    在这里插入图片描述
    再举个例子,将0xe3f转换为十进制,计算规则如下:

    0xe3f=> 14*162 +3*161 +15*160 = 3584 + 48 + 15 = 3647

    4.位运算

    4.1.位运算规则

    • 所有的位运算都是补码之间的运算
    • 所有的位运算得到的都是补码,需要将补码转换为原码才是最终结果
    • 正数的原码与反码补码相同,负数的原码为补码-1之后再取反码

    4.2.与(&)运算

    二进制中两个操作数都为1,结果才为1,即:
    1 & 1 = 1
    1 & 0 = 0
    0 & 1 = 0
    0 & 0 = 1
    将两个操作数转换为二进制后,进行按位与运算。如:

    56 & 78 => 00111000 & 01001110 = 00001000 = 8

    4.3.或(|)运算

    二进制中两个操作数至少有一个为1,结果才为1,即:
    1 | 1 = 1
    1 | 0 = 1
    0 | 1 = 1
    0 | 0 = 0
    将两个操作数转换为二进制后,进行按位或运算。如:

    56 | 78 => 00111000 | 01001110 = 01111110 = 126

    4.4.非(~)运算

    非运算是二进制中对每个操作数取反,即~0=1,~1=0,二进制数经过非运算后得到是补码,如果结果是正数(最高位为0)则补码即是原码,如果结果是负数(最高位为1)则需要将补码转换为原码如:
    35 对应的二进制为 00100011
    ~00100011结果为 11011100 最高位是1即为负数,需要将此补码转换为原码,负数的原码计算规则为 补码-1然后取反码,先将补码-1即11011100 -1 = 11011011,再按位取反,即10100100 = 36,故~35 = -36

    4.5.异或(^)运算

    二进制中两个操作数相同为0,两个操作数不同为1,即:
    1 ^ 1 = 0
    1 ^ 0 = 1
    0 ^ 1 = 1
    0 ^ 0 = 0
    将两个操作数转换为二进制后,进行按位异或运算。如:

    56 ^ 78 => 00111000 ^ 01001110 = 01110110 = 118

    4.6.移位(<<   >>   >>>)运算

    4.6.1 <<运算符

    左移运算符,将对象转换为二进制后每个操作数向左移动指定位数,低位补0

    56 << 3 ==> 00111000 << 3 ==> 001 11000000 ==> 28 + 27 + 26 = 448

    过程如下:
    在这里插入图片描述

    4.6.2 >>运算符

    有符号右移运算符,将对象转换为二进制后每个操作数向右移动指定位数,采用符号位扩展机制:正数(符号位为0)高位补0;负数(符号位为1)高位补1

    • 正数的有符号右移运算如下:

    56>>3 ==> 00111000 >> 3 ==>00000111 ==> 7
    过程如下:
    在这里插入图片描述

    • 负数的有符号右移运算如下:

    -56 >> 3
    -56原码为10111000,先转为补码为11001000,再将补码右移2位(高位)结果为11111001,
    得到的补码为负数,需要将此补码转换为原码,即先-1再取反码,即
    11111001 - 1 =11111000 再取反码为 10000111 ,即最终结果为-7

    4.6.3 >>>运算符

    无符号右移运算符将对象转换为二进制后每个操作数向右移动指定位数,无论正数负数都是高位补0,所以正数的有符号右移运算和无符号右移运算结果相同,负数的有符号右移运算和无符号右移运算结果不同。无符号右移运算仅对32位和64位有意义,因为在表达式中较小的值会自动提升为int值,这意味着符号扩展并且位移只发生在32位值上而不是8位或16位值上

    • 正数的无符号移位运算如下:

    56>>>3 ==> 00111000 >>> 3 ==>00000111 ==> 7

    • 负数的无符号右移如下:

    -56 >>> 3
    -56原码为10111000,先转为补码为11001000,再将补码右移3位,因为高位补0并且会自动转换为int值即32位,因此需要将32位补码全部修改,故右移后得到的值为00011111 11111111 11111111 11111001,最高位为0即为正数,即原码与补码相同,故最终结果为 228 + 227 + 226 + … + 25 + 24 + 23 + 20 = 229 - 22 - 21 = 536870905

    5.java中基础类型取值范围

    java虚拟机中一个字节占用8位,其中short占用2字节,int占用4字节,long占用8字节。

    • short占用2个字节,即二进制位16位,其中最高位为符号位,则short的取值范围二进制为[11111111 11111111,01111111 11111111],十进制为[-215, 215-1]
    • int占用4个字节,即二进制位32位,其中最高位为符号位,则int的取值范围二进制为[11111111 11111111 11111111 11111111,01111111 11111111 11111111 11111111],十进制为[-231, 231-1]
    • long占用8个字节,即二进制位64位,其中最高位为符号位,则long的取值范围十进制为[-263, 263-1]
    • float占用4个字节,即二进制32位,其中1位符号位,8位指数位即指数位即指数最大值为27-1=127,23位小数部分尾数,即float最大值为2128-1
      在这里插入图片描述
    • double占用8字节,即二进制64位,其中1位符号位,11位指数位即指数最大值为210-1=1023,52位小数部分尾数,即double最大值为21024-1
    展开全文
  • 直接看代码 public class TestDemo { public static void main(String[] args) { /* 符号为:最高位同时表示图号,0为正数,1为负数 */ /* 1、二进制转换为十进制 ... 二进制转换为10进制的

    直接看代码

    public class TestDemo {  
    	public static void main(String[] args) {  
            
            /* 符号为:最高位同时表示图号,0为正数,1为负数 */  
              
            /*  
                1、二进制转换为十进制 
     
                二进制转换为10进制的规律为: 每位的值 * 2的(当前位-1次方) 
                例如: 
             00000001 = 0 * 2^7 + 0 * 2^6 + 0 * 2^5 + 0 * 2^4 + 0 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0  = 1 
             00000010 = 0 * 2^7 + 0 * 2^6 + 0 * 2^5 + 0 * 2^4 + 0 * 2^3 + 0 * 2^2 + 1 * 2^1 + 0 * 2^0  = 2 
                     
                2、二进制的符号位: 
                最高位表示符号位,0表示正数  , 1表示负数                  
                 
                3、将二进制负数转换为十进制
    	先对该二进制数取反,然后加1,再转换为十进制,然后在前面加上负号 
               例如: 
           10101011 最高位为1,所以为负数 
                       第一步:取反: 01010100 
                       第二步:加1 : 01010101 
                       第三步:转换为10进制:85 
                       第四步:加上负号: -85 
                       所以      10101011 转换为十进制为 -85 
                        
                4、将十进制负数转换为二进制
    	先得到该十进制负数的绝对值,然后转换为二进制,然后将该二进制取反,然后加1 
    	例如:
    	  -85 
                    第一步:得到绝对值 85 
                    第二步:转换为二进制:01010101 
                    第二步:取反:                10101010 
                    第三步:加1:                 10101011 
                    所以,-85转换为二进制为  10101011 
             */  
              
            /* 
            ~ ‘非’ 运算符是将目标数的进制去反,即0变成1 ,1变成0 
            2的二进制码为 00000010 , 它取反为11111101 ,可见取反后结果为负数(二进制负数转换为十进制的步骤为:将二进制取反,然后+1) 
    	         将 11111101 转换为10进制 ,第一步取反 得到 00000010 然后 加1 得到 00000011 ,得到的结果为3 ,然后在前面加上负号就可以了 
    	         所以结果为-3 
             */  
            System.out.println(~2);  //-3
              
            /* 
              ^ 异或 ,计算方式为:两个二进制数的位相同则为0 不同则为1 
              23转换为二进制为:00010111 
              12转换为二进制为:00001100 
                               计算结果为:00011011  =  27 
             */  
            System.out.println(23 ^ 12);   //27
              
            /*
             *  & 按位与 ,计算方式为:两个二进制数的位都为1则为1 ,否则为0 
             */
             /*	例如1&2
             1的二进制为 :00000001 
             2的二进制为 :00000010 
                           结果为 :00000000 = 0 */            
            System.out.println(1&2);  //0
            
            /*	例如128&129
            128的二进制为 :10000000 
            129的二进制为 :10000001 
                          结果为 :10000000 = 128 */
            System.out.println("128 和129 与的结果是:"+(128&129)); //128
              
            /* 
             * | 按位或 ,计算方式为:两个二进制位有一个为1就为1,否者为0 
             */
              /* 例如5|6
              5 的二进制为:00000101 
              6 的二进制为:00000110 
                              结果为:00000111 = 7*/            
            System.out.println(5|6);    //7 
            
            /* 例如128|129
            128的二进制为 :10000000 
            129的二进制为 :10000001 
                          结果为 :10000001 = 129 */ 
            System.out.println("128 和129 或的结果是:"+(128|129)); //129
              
            /* 
              >> 右移运算符(num >> 1,相当于num除以2),符号左边表示要被移位的数,右边表示需要移的位数,结果为正数则在左边补0,否则补1 
              3 的二进制为:00000010 
                              向右移动1位:00000001 = 1  
             */  
            System.out.println(3 >> 1);  //1
            
            /* 
             << 左移运算符(num << 1,相当于num乘以2),符号左边表示要被移位的数,右边表示需要移的位数,结果为正数则在右边补0,否则补1 
             3 的二进制为:00000010 
                            向左移动1位:00000100 = 6  
           */  
            System.out.println(3 << 1);  //6
          
          /* 
            >>> 无符号右移,符号左边表示要被移位的数,右边表示需要移的位数,忽略符号位,空位都以0补齐
            3 的二进制为:00000010 
                        向右移动1位:00000001 = 1  
         */  
        	System.out.println(3 >>> 1);  //1
        }  
    } 


    展开全文
  • /**通过二进制测试 遍历背包中选中可以出售的的装备列表 */     public static getCanSellEquipList(rareList: number, starList: number): cl....
  • 二进制运算

    2020-11-20 17:50:16
    二进制操作 Java基础系列-二进制操作 & “运算 都为1则为1,否则为0 | “运算 有1为1,全0为0 ~ “运算 0为1,1为0 ^ “亦运算 相同为0 ,不同为1 << “左移”运算 符号位保持不变情况...
  • 二进制的运算详解

    千次阅读 2017-12-19 18:25:30
    ① 将数转化为二进制(实际机器操作中本身就是二进制,这里意思是人工计算) ② 每一位都进行如下运算: a) 11与运算得1 b) 10(01)与运算得0 c) 00与运算得0 两个数按位进行或运算特点有: ...
  • 这里做一下非运算的demo,因为非对比其它几个运算会绕一下,、异或形式比较直接,就不展示了。 代码如下: 结果展示: 在这里详细说明一下为什么为会是这个效果: 3补码如下 3(补码) ->
  • 逻辑 (&&) :两者值都为1才取1,否则为0 逻辑 ( || ):只要有1就取1,否则为0 逻辑 ( ! ) :若是0,则取1,若是1,则取0 逻辑异或 (⊕):若两者值相同,则为0,若两者值不同,则为1 若能给你带来...
  • 二进制,是最简单 1.表示简单 自然界有很多两种相对对立,稳定两种状态,可以代表0 1 例如电压高低,有无磁场 例如纸带,用上面打孔还是不打孔, ...与或非 异或运算 XOR 运算 就等同于两个一位二进制数相加 ...
  • 前言 前面的课程有粉丝评论说没看懂,本id回去细看了一下,确实写得...为什么要讲这个,因为计算机的本质就是这些二进制的逻辑运算。计算机之所以用二进制,是因为受硬件条件的制约。但是即便是这么简单的0和1,...
  • 前言前面的课程有粉丝评论说没看懂,本id回去细看了一下,...为什么要讲这个,因为计算机的本质就是这些二进制的逻辑运算。计算机之所以用二进制,是因为受硬件条件的制约。但是即便是这么简单的0和1,照样能实现强...
  • 1. (or |) 只要有一个为1,就为1。 2. (and &) 两个都为1,就为1。 3. 异或(xor ^) 两个不一样时,就为1。 4. (not !...2. 如何获取某个值第n位二进制)值是多少? 例如:如何获取0x8F
  • using System; using System.Collections.Generic; using System.Linq; using System.Text;... /// 二进制授权帮助类,最多支持 62 种不同权限,鉴权值最大为262次方(即:4611686018427387904) ///
  • 二进制知识之位运算,

    2017-07-02 23:22:13
    如果您不知道下面的运算结果话认真理解这篇文章或许可以帮助到你 echo '~-5=',~-5; echo '2&3=',2&3;...#或非与的运算笔记 二进制,电子计算机内部都是用二进制补码方式运算(最高位0表正数,1为负数)
  • 以上是最终效果 实现类: package com.corejava.chap02; public class IntBin { private int value; public IntBin(int value) { this.value = value; } public void display() { ... ...
  • 本期笔试经解析题目来源紫光展锐IC笔试题,共10道不定项选择题,涉及知识点包含:动态功耗、Verilog语言、二进制有符号数、仿真文件Testbench等。今天解析内容是紫光展锐数字IC岗不定项选择题最后一部分。16、...
  • 位运算符有:左移( <...)、( |)、(~)、异或(^),( ~ ) 除非运算为一元操作符外,其它都是二元操作符。 1、左移( <<) 将6左移2位:6<<2 0000 0110 然后左移2位后,低位补0: 0...
  • 二进制常用运算简介:逻辑变量之间的运算称为逻辑运算二进制数1和0在逻辑上可以代表“真”“假”、“是”“否”、“有”“无”。这种具有逻辑属性变量就称为逻辑变量。 计算机逻辑运算的算术运算的主要...
  • 网上见到一道题目,要求用与或非等逻辑运算实现计算a+b题目。这里我想借着这道题,记录一下自己思路,留作以后温故。 假设 整数 a 、b都是正数 a = 6,二进制表示为 0110 b = 4 ,二进制表示为 0100 我们需要...
  • 今天文章和大家聊聊 Python Numpy 位运算和算术函数...NumPy 位运算函数如下:函数描述bitwise_and对数组元素执行位运算bitwise_or对数组元素执行位运算invert按位取反(位非运算)left_shift向左移动二进制表示...
  • Java提供位运算符有:左移( > ) 、无符号右移( >>> ) 、位( & ) 、位( | )、位( ~ )、位异或( ^ ),除了位( ~ )是一元操作符外,其它都是二元操作符。 1、左移( Test1、将5左移2
  • 一元运算符? i++和++i 独立运算时,运算的结果时完全相同。但是如果将i++或者++i赋值/打印/获取时,那么运算的先后顺序和赋值先后顺序将产生改变。 ...0001 1100 1010 1ca 二进制与十六进制...
  • 二进制逻辑运算详解

    2009-08-17 19:04:43
    二进制数1和0在逻辑上可以代表“真”“假”、“是”“否”、“有”“无”。这种具有逻辑属性变量就称为逻辑变量。 计算机逻辑运算的算术运算的主要区别是:逻辑运算是按位进行,位位之间不像加减运算...
  • 2.,异或,左移,右移,负数右移相关知识 3.python数据类型 我们从一个题目说起,该题来自于《剑指offer》。 题目描述:输入一个整数,输出该数二进制表示中1个数。其中负数用补码表示。 解题思路:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,065
精华内容 426
关键字:

二进制的与或非运算