精华内容
下载资源
问答
  • 计算机在处置惩罚数据时,一次能... 计算机在存储、传送或操纵时,作为一个单元的一组二进制码称为字,一个字中的二进制位的位数称为字长。平常称处置惩罚字长为8位数据的CPU叫8位CPU,32CPU就是在同一时间内处置...

    计算机在处置惩罚数据时,一次能直接处置惩罚的二进制数据的位数称为:字长。字长是指计算机一次能直接处置惩罚的二进制数据的位数,字长越长,计算机的团体机能越强。

    8cebf795fa7a907e92238009d682dbc8.png

    计算机采纳二进制编码体式格局示意数、字符、指令和别的掌握信息。 计算机在存储、传送或操纵时,作为一个单元的一组二进制码称为字,一个字中的二进制位的位数称为字长。

    平常称处置惩罚字长为8位数据的CPU叫8位CPU,32位CPU就是在同一时间内处置惩罚字长为32位的二进制数据。二进制的每个0或1是构成二进制的最小单元,称为位(bit)。经常使用的字长为8位、16位、32位和64位。字长为8位的编码称为字节,是计算机中的基础编码单元。

    字长与计算机的功用和用处有很大的关联,是计算机的一个主要技术目标。字长直接反应了一台计算机的计算精度,为顺应差别的请求及谐和运算精度和硬件造价间的关联,大多数计算机均支撑变字长运算,即机内可完成半字长、全字长(或单字长)和双倍字长运算。在其他目标相同时,字长越大计算机的处置惩罚数据的速率就越快。初期的微机字长平常是8位和16位,386以及更高的处置惩罚器大多是32位。市面上的计算机的处置惩罚器大部分已达到64位。字长由微处置惩罚器对外数据通路的数据总线条数决议。

    更多相干学问,请接见:Ki4网!

    以上就是计算机一次能直接处置惩罚的二进制数据的位数称为什么?的细致内容,更多请关注ki4网别的相干文章!

    收藏 | 0

    展开全文
  • 二进制位运算符

    2021-10-08 11:21:45
    二进制位运算符用于直接对二进制位进行计算,一共有7个。 二进制或运算符(or):符号为|,表示若两个二进制位都为0,则结果为0,否则为1。 二进制与运算符(and):符号为&,表示若两个二进制位都为1,则结果...

    概述

    二进制位运算符用于直接对二进制位进行计算,一共有7个。

    • 二进制或运算符(or):符号为|,表示若两个二进制位都为0,则结果为0,否则为1
    • 二进制与运算符(and):符号为&,表示若两个二进制位都为1,则结果为1,否则为0。
    • 二进制否运算符(not):符号为~,表示对一个二进制位取反。
    • 异或运算符(xor):符号为^,表示若两个二进制位不相同,则结果为1,否则为0。
    • 左移运算符(left shift):符号为<<,详见下文解释。
    • 右移运算符(right shift):符号为>>,详见下文解释。
    • 头部补零的右移运算符(zero filled right shift):符号为>>>,详见下文解释。

    这些位运算符直接处理每一个比特位(bit),所以是非常底层的运算,好处是速度极快,缺点是很不直观,许多场合不能使用它们,否则会使代码难以理解和查错。

    有一点需要特别注意,位运算符只对整数起作用,如果一个运算子不是整数,会自动转为整数后再执行。另外,虽然在 JavaScript 内部,数值都是以64位浮点数的形式储存,但是做位运算的时候,是以32位带符号的整数进行运算的,并且返回值也是一个32位带符号的整数。

    i = i | 0;
    

    上面这行代码的意思,就是将i(不管是整数或小数)转为32位整数。

    利用这个特性,可以写出一个函数,将任意数值转为32位整数。

    function toInt32(x) { return x | 0;
    }
    

    上面这个函数将任意值与0进行一次或运算,这个位运算会自动将一个值转为32位整数。下面是这个函数的用法。

    toInt32(1.001) // 1 toInt32(1.999) // 1 toInt32(1) // 1 toInt32(-1) // -1 toInt32(Math.pow(2, 32) + 1) // 1 toInt32(Math.pow(2, 32) - 1) // -1 

    上面代码中,toInt32可以将小数转为整数。对于一般的整数,返回值不会有任何变化。对于大于或等于2的32次方的整数,大于32位的数位都会被舍去。

    二进制或运算符

    二进制或运算符(|)逐位比较两个运算子,两个二进制位之中只要有一个为1,就返回1,否则返回0

    0 | 3 // 3 

    上面代码中,03的二进制形式分别是0011,所以进行二进制或运算会得到11(即3)。

    位运算只对整数有效,遇到小数时,会将小数部分舍去,只保留整数部分。所以,将一个小数与0进行二进制或运算,等同于对该数去除小数部分,即取整数位。

    2.9 | 0 // 2 -2.9 | 0 // -2 

    需要注意的是,这种取整方法不适用超过32位整数最大值2147483647的数。

    2147483649.4 | 0; // -2147483647 

    二进制与运算符

    二进制与运算符(&)的规则是逐位比较两个运算子,两个二进制位之中只要有一个位为0,就返回0,否则返回1

    0 & 3 // 0 

    上面代码中,0(二进制00)和3(二进制11)进行二进制与运算会得到00(即0)。

    二进制否运算符

    二进制否运算符(~)将每个二进制位都变为相反值(0变为11变为0)。它的返回结果有时比较难理解,因为涉及到计算机内部的数值表示机制。

    ~ 3 // -4 

    上面表达式对3进行二进制否运算,得到-4。之所以会有这样的结果,是因为位运算时,JavaScript 内部将所有的运算子都转为32位的二进制整数再进行运算。

    3的32位整数形式是00000000000000000000000000000011,二进制否运算以后得到11111111111111111111111111111100。由于第一位(符号位)是1,所以这个数是一个负数。JavaScript 内部采用补码形式表示负数,即需要将这个数减去1,再取一次反,然后加上负号,才能得到这个负数对应的10进制值。这个数减去1等于11111111111111111111111111111011,再取一次反得到00000000000000000000000000000100,再加上负号就是-4。考虑到这样的过程比较麻烦,可以简单记忆成,一个数与自身的取反值相加,等于-1。

    ~ -3 // 2 

    上面表达式可以这样算,-3的取反值等于-1减去-3,结果为2

    对一个整数连续两次二进制否运算,得到它自身。

    ~~3 // 3 

    所有的位运算都只对整数有效。二进制否运算遇到小数时,也会将小数部分舍去,只保留整数部分。所以,对一个小数连续进行两次二进制否运算,能达到取整效果。

    ~~2.9 // 2 ~~47.11 // 47 ~~1.9999 // 1 ~~3 // 3 

    使用二进制否运算取整,是所有取整方法中最快的一种。

    对字符串进行二进制否运算,JavaScript 引擎会先调用Number函数,将字符串转为数值。

    // 相当于~Number('011') ~'011' // -12 // 相当于~Number('42 cats') ~'42 cats' // -1 // 相当于~Number('0xcafebabe') ~'0xcafebabe' // 889275713 // 相当于~Number('deadbeef') ~'deadbeef' // -1 

    Number函数将字符串转为数值的规则,参见《数据的类型转换》一章。

    对于其他类型的值,二进制否运算也是先用Number转为数值,然后再进行处理。

    // 相当于 ~Number([]) ~[] // -1 // 相当于 ~Number(NaN) ~NaN // -1 // 相当于 ~Number(null) ~null // -1 

    异或运算符

    异或运算(^)在两个二进制位不同时返回1,相同时返回0

    0 ^ 3 // 3 

    上面表达式中,0(二进制00)与3(二进制11)进行异或运算,它们每一个二进制位都不同,所以得到11(即3)。

    “异或运算”有一个特殊运用,连续对两个数ab进行三次异或运算,a^=b; b^=a; a^=b;,可以互换它们的值。这意味着,使用“异或运算”可以在不引入临时变量的前提下,互换两个变量的值。

    var a = 10; var b = 99;
    
    a ^= b, b ^= a, a ^= b;
    
    a // 99 b // 10 

    这是互换两个变量的值的最快方法。

    异或运算也可以用来取整。

    12.9 ^ 0 // 12 

    左移运算符

    左移运算符(<<)表示将一个数的二进制值向左移动指定的位数,尾部补0,即乘以2的指定次方。向左移动的时候,最高位的符号位是一起移动的。

    // 4 的二进制形式为100, // 左移一位为1000(即十进制的8) // 相当于乘以2的1次方 4 << 1 // 8 -4 << 1 // -8 

    上面代码中,-4左移一位得到-8,是因为-4的二进制形式是11111111111111111111111111111100,左移一位后得到11111111111111111111111111111000,该数转为十进制(减去1后取反,再加上负号)即为-8

    如果左移0位,就相当于将该数值转为32位整数,等同于取整,对于正数和负数都有效。

    13.5 << 0 // 13 -13.5 << 0 // -13 

    左移运算符用于二进制数值非常方便。

    var color = {r: 186, g: 218, b: 85}; // RGB to HEX // (1 << 24)的作用为保证结果是6位数 var rgb2hex = function(r, g, b) { return '#' + ((1 << 24) + (r << 16) + (g << 8) + b)
        .toString(16) // 先转成十六进制,然后返回字符串 .substr(1); // 去除字符串的最高位,返回后面六个字符串 }
    
    rgb2hex(color.r, color.g, color.b) // "#bada55" 

    上面代码使用左移运算符,将颜色的 RGB 值转为 HEX 值。

    右移运算符

    右移运算符(>>)表示将一个数的二进制值向右移动指定的位数。如果是正数,头部全部补0;如果是负数,头部全部补1。右移运算符基本上相当于除以2的指定次方(最高位即符号位参与移动)。

    4 >> 1 // 2 /*
    // 因为4的二进制形式为 00000000000000000000000000000100,
    // 右移一位得到 00000000000000000000000000000010,
    // 即为十进制的2
    */ -4 >> 1 // -2 /*
    // 因为-4的二进制形式为 11111111111111111111111111111100,
    // 右移一位,头部补1,得到 11111111111111111111111111111110,
    // 即为十进制的-2
    */ 

    右移运算可以模拟 2 的整除运算。

    5 >> 1 // 2 // 相当于 5 / 2 = 2 21 >> 2 // 5 // 相当于 21 / 4 = 5 21 >> 3 // 2 // 相当于 21 / 8 = 2 21 >> 4 // 1 // 相当于 21 / 16 = 1 

    头部补零的右移运算符

    头部补零的右移运算符(>>>)与右移运算符(>>)只有一个差别,就是一个数的二进制形式向右移动时,头部一律补零,而不考虑符号位。所以,该运算总是得到正值。对于正数,该运算的结果与右移运算符(>>)完全一致,区别主要在于负数。

    4 >>> 1 // 2 -4 >>> 1 // 2147483646 /*
    // 因为-4的二进制形式为11111111111111111111111111111100,
    // 带符号位的右移一位,得到01111111111111111111111111111110,
    // 即为十进制的2147483646。
    */ 

    这个运算实际上将一个值转为32位无符号整数。

    查看一个负整数在计算机内部的储存形式,最快的方法就是使用这个运算符。

    -1 >>> 0 // 4294967295 

    上面代码表示,-1作为32位整数时,内部的储存形式使用无符号整数格式解读,值为 4294967295(即(2^32)-1,等于11111111111111111111111111111111)。

    开关作用

    位运算符可以用作设置对象属性的开关。

    假定某个对象有四个开关,每个开关都是一个变量。那么,可以设置一个四位的二进制数,它的每个位对应一个开关。

    var FLAG_A = 1; // 0001 var FLAG_B = 2; // 0010 var FLAG_C = 4; // 0100 var FLAG_D = 8; // 1000 

    上面代码设置 A、B、C、D 四个开关,每个开关分别占有一个二进制位。

    然后,就可以用二进制与运算,检查当前设置是否打开了指定开关。

    var flags = 5; // 二进制的0101 if (flags & FLAG_C) { // ... } // 0101 & 0100 => 0100 => true 

    上面代码检验是否打开了开关C。如果打开,会返回true,否则返回false

    现在假设需要打开ABD三个开关,我们可以构造一个掩码变量。

    var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011 

    上面代码对ABD三个变量进行二进制或运算,得到掩码值为二进制的1011

    有了掩码,二进制或运算可以确保打开指定的开关。

    flags = flags | mask;
    

    上面代码中,计算后得到的flags变量,代表三个开关的二进制位都打开了。

    二进制与运算可以将当前设置中凡是与开关设置不一样的项,全部关闭。

    flags = flags & mask;
    

    异或运算可以切换(toggle)当前设置,即第一次执行可以得到当前设置的相反值,再执行一次又得到原来的值。

    flags = flags ^ mask;
    

    二进制否运算可以翻转当前设置,即原设置为0,运算后变为1;原设置为1,运算后变为0

    flags = ~flags;
    展开全文
  • 逻辑运算,属性设置按逻辑运算在高...有一点要注意就是,所有按运算都是二进制位的按运算,如果数据采用十进制或者十六进制表示,实际上也是采用二进制的按运算。按与: & 0&0=0; 1&0=0; 0&1=0; 1&1=1

    按位逻辑运算,属性设置

    按位逻辑运算在高效率的数据操作中应用很多,平时用的高级语言里面,多数时候不需要我们去手动设置这些,因为已经被封装在各种模块/类里面了。

    在需要手动定义一些功能的时候,这些运算方法很值得使用。
    有一点要注意就是,所有按位运算都是二进制位的按位运算,如果数据采用十进制或者十六进制表示,实际上也是采用二进制的按位运算。

    按位与: &

     0&0=0; 1&0=0; 0&1=0; 1&1=1;
    

    (1不变,0变为0)
    例如 : 1001&0011 = 0001
    负数在计算机中是按照补码的形式存储的,所以要按照补码来按位运算
    应用:
    1,把指定位清零 。只需要和指定位为0,其他位为1的数进行&运算,这些位就为被置0
    2,获取指定位。构造一个二进制数,需要获取的位为1,其他位为0,按位&运算,其结果就是数据的指定位。

    按位或: |

    0|0=0;   0|1=1;   1|0=1;    1|1=1;
    

    (0不变,1变为1)
    应用:
    1,把数据的指定位设置为1。例如,如果要把第四位设置为1,那么需要构造一个二进制数:1000,将其与数据进行|预算,那么数据的第四位就会设置为1(不论之前是否是1)

    按位异或:^

    0^0=0;   0^1=1;   1^0=1;   1^1=0;
    

    (0不变,1反转)
    应用:
    1,与1异或,可以翻转
    2,与0异或,可以保留原值。
    这两点很明确。

    按位取反:~

    ~1=0;   ~0=1;
    

    一个按位逻辑运算的应用:属性设置(这个应该有一个学名,暂时还不知道怎么说)

    要对一个项目设置一些属性。如果是唯一性的属性倒还好办,比如说,一个项目,可能的属性为a,b,c,只能是其中一种,那么只需要设置这些属性值为一个静态常量,然后去判断一下就好了。

    但是很多时候需要设置的属性是多种叠加的。比如说,可能属性是,a,b,c,d,e,f,g。
    可以是其中一种,或者几种,可以是ac,也可以是dfg,也可以是e。并且这些属性并没有明确的分类,大多数都是同一类属性的叠加,所以不能分到不同的属性值里面去。
    具体来讲,一个窗口,可以是 前台/最大化/透明/窗口化/默认位置/保持最上层 等等这些属性的一个或者几个的叠加。一个文件可以是 文件/文件夹/系统文件/隐藏文件/用户文件 等等这些的一个或者几个的叠加。

    这个时候,像唯一属性那样判断就不好用了。最好的办法就是用按位逻辑运算

    假设一个项目的属性有8种。那么就构造一个8位二进制数(也就是2位十六进制数)。每一位对应一个属性,设置成静态常量。
    a: 0000 0001
    b: 0000 0010
    c: 0000 0100
    d: 0000 1000
    …………
    如此一来,就可以用按位逻辑运算来构造属性值了。
    比如说,我的属性值是abc,那么构造出的值就是:a|b|c.
    根据之前的描述,| 运算将会使得对应1的位置是1,也就是说,a|b|c = 0000 0111,这也是一个唯一值,跟所有8种可能属性都不重复。类似的,我们也可以构造出其他的叠加属性,0100 1101,1001 0000 等等

    判断属性的时候,需要用到 & 运算。
    例如,判断一个项目是否有 a属性,可以:if((attr&a)==a)
    根据上面的描述,& 的功能是 :0变为0,1不变。也就是说, attr的值,对应a里面的为0的位,不管是否是0,都会编程0;对应a里面为1的位,则保持不变。
    所以,如果attr有a这个属性,那么它的对应a属性的位就会是1,就保持为1;如果没有a这个属性,对应为就是0,运算后依然是0。
    而其他位,不管是否是0,都会变成0.因此,可以用if((attr&a)==a)来判断属性。

    同理,设置属性的时候用到 | 运算。
    假设attr要设置成abcd,只需要简单的这样: attr = a|b|c|d;就可以了

    大数(超过32位二进制数)

    C语言早已支持64位,有单独的方法操作64位数(目前为止还没有试验过),但是多数时候我们还是在32位里面运算。

    在没有支持64位数的时期,要存储一个大数据,比如文件大小,需要用到高低位的存储方法。就是说,在属性里面会对应两个值,一个是低32位,一个是高32位。

    在数据量比较小的时候,高位始终为0。如果数据量在低位溢出,就会在高位中 +1。
    需要注意一点就是,如果直接写出来的话,只有二进制/十六进制可以直接表示为 【高位-低位】,例如一个数是低位0x1820 ff11, 高位是0x1,那表示出来就是 0x1 1820 ff11
    如果是十进制,就需要转换一下,因为高位的 0x1 表示成十进制的时候是 32位最大值+1

    如果要做加法,需要高位/低位分开相加,如果低位产生了进位,那就在高位的结果里面加1.
    怎么判断低位的进位呢?
    如果是无符号数,就简单了,因为进位以后的32位值对应的就只有这32位的值,第33位会被计算机直接忽略,所以,如果 结果小于任意一个相加值,就表示产生了进位。
    numA + numB = result;
    if(result<numA)…………
    有符号数的情况还没有研究过。刚才这个方法也是在网上找到的,还没细看是否有bug。

    高低位的表示方法转换成10进制

    result = HIGH*(MAXDWORD + 1) + LOW
    result – 真实结果
    MAXDWORD – 32位数最大值 (0xFFFF FFFF)

    那么,怎么表示在计算机里面呢?
    0xFFFF FFFF 十进制 就是 4 294 967 295,0x1 0000 0000 实际数值是 4 294 967 296,但是计算机里面直接把超过32位的数值舍去,所以计算机里面这个数就是0x0000 0000,也就是十进制数0

    要在计算机上表示超过32位的数值,可以使用以下办法。(自己想的办法,不知道是不是实用)

    保存一个指定位数(例如,20位十进制数)的字符数组char bit[20];
    将这个数组的每一个位上的字符,对应十进制数的每一个位的数字,然后按照普通的算法进行加减乘除操作。
    加法就是 对位相加,如果进位,就在上一位加1。
    乘法类似。
    除法还没有仔细想过,以后再说吧。

    所以,超过32位的数值可以用这种按位表示法来保存,输出的时候也不会存在溢出的问题。

    展开全文
  • 二进制位运算

    千次阅读 2016-01-30 13:48:59
    权:数制中每一固定位置对应的单位值,也就是某一上的“1”所表示的数值的大小,称为该权. 比如10进制数:1234, 个位位权1*10^0=1; 十位位权1*10^1=10;... 二进制和十进制的转换:比如67这个数

    基本数据类型所占字节和位数

    Java的基本数据类型,以及在内存中所占的位数。(一个字节等于8位)

    数据类型所占字节所占位数
    byte18
    boolean18
    short216
    int432
    long864
    float432
    double864
    char216

    十进制转r进制总结

    方法:除r取余,直至商0,余数倒叙排列!
    比如67这个数

    十进制转换成二进制 采用短除2法:

    余数
    67 ÷ 2331
    33 ÷ 2161
    16 ÷ 280
    8 ÷ 240
    4 ÷ 220
    2 ÷ 210
    1 ÷ 201

    商是0的时候结束,将余数从下往上数,即可得到二进制数结果 1000011

    二进制转换成十进制

    采用科学计数法,按位权展开;
    比如上面这个数1000011

     1*2^(1-1)+1*2^(2-1)+1*2^(7-1)=1+2+64=67;     
    

    二进制的位运算

    基本概念

    1,先介绍二进制中几个基本的概念原码,反码,补码:
    补充一下所有计算机中这些码可以理解为一种规定标准,就是说计算机里以何种标准来存储二进制;

    • 在计算机中,参与运算的是二进制数的补码形式

    原码

    就是一个数的二进制形式,比如

     00000000 00000000 00000000 00001000	//是8(int)的原码
     10000000 00000000 00000000 00001000	//是-8(int)的原码
    

    其中,最高位为符号位:正数为0,负数为1。剩下的n-1位表示该数的绝对值,

    PS:正数的原、反、补码都一样

    • 0的原码跟反码都有两个,因为这里0被分为+0和-0。

    反码

    反码就是在原码的基础上,符号位不变其他位按位取反 (就是0变1,1变0)就可以了
    对于负数 它的原码各个位数取反 。比如 -8

    10000000 00000000 00000000 00001000	//取反
    11111111 11111111 11111111 11110111
    

    补码

    补码就是在反码的基础上+1.
    例如-8表示如下:
    -8的二进制代码

    10000000 00000000 00000000 00001000
    

    取反后的反码

    11111111 11111111 11111111 11110111
    

    末位加上1得补码

    11111111  11111111 11111111 11111000
    

    二进制逢2进1

    总结

    正数:

    • 原码=反码=补码

    负数:

    • 原码
    • 反码 = 其原码除符号位之外的各位取反
    • 补码=反码+1 (如果+1之后有进位的,要一直往前进位,包括符号位)

    二进制位运算

    在二进制里面

    • 整型int使用32个字节,32位,其中最高位为0表示的是正数,最高位为1表示的是负数
    • 其中0含义代表的是false,1含义表示true
    • 在接触位运算符的时候,把1想成true,把0想成false,结果为true代表1,结果为false代表0,

    这个感觉是不是和java逻辑运算符差不多!

    &运算

    • 按位与运算 两位都为1,结果才是1;0&0=0;0&1=0;1&0=0;1&1=1
    • 是不是可以理解成两个都为true,结果才是true*
    		int a = 8;// 8(10)==00000000 00000000 00000000 00001000(2)
    		int b = 9;// 9(10)==00000000 00000000 00000000 00001001(2)
    		int c = a & b;// == 00000000 00000000 00000000 00001000(2)
    		System.out.println(c);// c=8
    

    按位与运算的应用

    可以判断一个数x的奇偶性

    • x&1=0,说明x是偶数
    • x&1=1,说明x是奇数
    		System.out.println(a & 1);// 结果0,说明a是偶数
    		System.out.println(b & 1);// 结果1,说明b是奇数
    

    保留指定的位数

    比如想保留数a的后8位

    • 0xff是16进制,转换二进制00000000 00000000 11111111 1111111
    		System.out.println(a = a & 0xff);// ==00000000 00000000 00000000 00001000(2)
    		System.out.println(Integer.toBinaryString(a & 0xff));
    

    | 或运算

    • 按位或 只要有一个为1,结果就为1;0|0=0;0|1=1;1|0=1;1|1=1
    • 是不是可以理解成两个中有一个为true,结果就是true
    		int a = 8;// 8(10)==00000000 00000000 00000000 00001000(2)
    		int b = 9;// 9(10)==00000000 00000000 00000000 00001001(2)
    		int c = a | b;// == 00000000 00000000 00000000 00001001(2)
    		System.out.println(c);// c=9
    

    按位或运算的应用;

    将一个数x指定位全部换成1

    比如上面的a

    	int a = 8;// 8(10)==00000000 00000000 00000000 00001000(2)
    
    		//数a的后8位全部变成1
    		System.out.println(a = a | 0xff);//== 00000000 00000000 00000000 11111111(2)
    		System.out.println(Integer.toBinaryString(a | 0xff));
    

    ^ 异或运算

    • 按位异或运算 相应位值不同,则该位结果为1,否则为0;00=0;01=1;10=1;11=0**
    • 是不是可以理解成两个都不为true或者false时,结果才是true
    		int a = 8;// 8(10)==00000000 00000000 00000000 00001000(2)
    		int b = 9;// 9(10)==00000000 00000000 00000000 00001001(2)
    		int c = a ^ b;// == 00000000 00000000 00000000 00000001(2)
    		System.out.println(c);// c=1
    

    按位异或的应用:

    定位反转

    • 将一个数x的0位变成1,1位变成0
    		System.out.println(a ^ 0xff);// == 00000000 00000000 00000000 11110111(2)
    		System.out.println(Integer.toBinaryString(a ^ 0xff));
    

    交换a和b的数值

    		a = a ^ b;
    		b = b ^ a;
    		a = a ^ b;
    		System.out.println(a);// 9
    		System.out.println(b);// 8
    

    ~ 按位取反

    • 按位取反 将一个位上的数按位取反,即0变成1,1变成0;~1=0 ; ~0=1
    • 是不是可以理解成!true,结果是false,!false,结果是true.

    先了解一下下面负数二进制表示形式;上面说了,负数以其正值的补码形式表示
    比如 int a = 8的取反过程

    	// 8原码             00000000 00000000 00000000 00001000(2)
    
    	//  取反             11111111 11111111 11111111 11110111(2) 是个负数
    
    	// 减1            	 11111111 11111111 11111111 11110110(2) 得到了负数绝对值的反码
    
    	// 取反              00000000 00000000 00000000 00001001(2) 的到了负数的绝对值
    
    	//转换十进制  等于   9,所以结果是 -9 ;
    	System.out.println(a);// -9
    
    • 负数以其正值的补码形式表示,补码等于负数绝对值的反码+1

    << 左移

    • 将一个运算对象的各二进制位全部左移若干位
    • 左边的二进制位丢弃,右边补0
    		int a = 8;// 8(10)== 00000000 00000000 00000000 00001000(2)
    		int b = -8;// -8(10)=11111111 11111111 11111111 11111000(2)
    		System.out.println(a << 1);// 00000000 00000000 00000000 00010000(2)==16(10)
    		System.out.println(b << 1);// 11111111 11111111 11111111 11110000(2)==-16(10)
    
    • 左移的规律:

    一个数y左移n位(y<< n),就相当于这个数乘以2^n;


    >>右移

    • 将一个运算对象的各个二进制位全部右移若干位
    • 是正数,左边的二进制位补0
    • 是负数,左边二进制位补1
    • 右边统统舍弃
    		int a = 8;// 8(10)== 00000000 00000000 00000000 00001000(2)
    		int b = -8;// -8(10)=11111111 11111111 11111111 11111000(2)
    		System.out.println(a >> 1);// 00000000 00000000 00000000 00000100(2)==16(4)
    		System.out.println(b >> 1);// 11111111 11111111 11111111 11111100(2)==-16(4)
    
    • 右移的规律

    一个数y右移n位(y>> n),就相当于这个数除以2^n;


    >>>无符号右移

    • 各个位向右移指定的位数
    • 右移后左边空出的位用零来填充
    • 移除右边的位被舍弃
    		int a = 8;// 8(10)== 00000000 00000000 00000000 00001000(2)
    		int b = -8;// -(10)=11111111 11111111 11111111 11111000(2)
    		System.out.println(a >>> 1);// 00000000 00000000 00000000 00000100(2)==4(4)
    		System.out.println(b >>> 1);// 01111111 11111111 11111111 11111100(2)==2147483644(4)
    

    Java中常见的进制转换

    		/**
    		 二进制:数字前面加上“0b”例如0b10010
    		 八进制:数字前面加上“0” 例如"0123"
    		 十六进制:数字前面加上“0x" 例如”0x12" 
    		 */
    		int num = 0b10010;
    		String str = "10010";
    		System.out.println(Integer.toBinaryString(num));// 转化为2进制
    		System.out.println(Integer.toString(num, 2));// 转化为2进制
    		System.out.println(Integer.toOctalString(num));// 转化为8进制
    		System.out.println(Integer.toString(num, 8));// 转化为8进制
    		System.out.println(Integer.toHexString(num));// 转化为16进制
    		System.out.println(Integer.toString(num, 16));// 转化为16进制
    		System.out.println(Integer.toString(num));// 转化为10进制
    		System.out.println(Integer.toString(num, 10));// 转化为10进制
    		System.out.println("-------------------------------------");
    		System.out.println(Integer.parseInt(str, 2));// 把2进制数解析成10进制
    		System.out.println(Integer.parseInt(str, 8));// 把8进制数解析成10进制
    		System.out.println(Integer.parseInt(str, 10));// 把10进制数解析成10进制
    		System.out.println(Integer.parseInt(str));// 默认把数看成是10进制,转化为10进制
    		System.out.println(Integer.parseInt(str, 16));// 把16进制数解析成10进制
    

    开发中位运算的小技巧

    判断int型变量a是奇数还是偶数

    • a&1 = 0 偶数

    • a&1 = 1 奇数

    求平均值

    比如有两个int类型变量x、y,首先要求x+y的和,再除以2,但是有可能x+y的结果会超过int的最大表示范围,所以位运算就派上用场啦

        (x&y)+((x^y)>>1); 
    

    对于一个大于0的整数,判断它是不是2的几次方

        ((x&(x-1))==0)&&(x!=0); 
    

    比如有两个int类型变量x、y,要求两者数字交换

    位运算的实现方法:性能绝对高效

    	   	x ^= y; 
    	
    	    y ^= x; 
    	
    	    x ^= y; 
    

    求绝对值

    	   int abs( int x ) 
    	  { 
    	    int y ; 
    	    y = x >> 31 ; 
    	   return (x^y)-y ;  
    	   //or: (x+y)^y 
    	  }
    

    取模运算

    采用位运算实现:

         a % (2^n) 等价于 a & (2^n - 1) 
    

    乘法运算

    采用位运算实现

         a * (2^n) 等价于 a << n
    

    除法运算转化成位运算

      	 a / (2^n) 等价于 a>> n 
    

    求相反数

          (~x+1) 
    

    a % 2 等价于 a & 1

    若有问题欢迎指正,互相学习,共同进步!

    展开全文
  • 16进制和二进制位的关系

    千次阅读 2017-05-02 15:02:28
    英文名称:hexadecimal number system(HEX) 它由0-9,A-F组成,字母不区分大小写。...一个字节个比特,就是二进制位四个二进制数最大表示为15,就是一个16进制数,所以八位可以表示成两个16进制的数!
  • 满意答案sqq2125272013.04.11采纳率:46%等级:12已帮助:10556... 编辑本段进制数 二进制数据的表示法 二进制数据也是采用位置计数法,其权是以2为底的幂。例如二进制数据110.11,其权的大小顺序为2^2、2^1、2^0...
  • Java将十进制转换为8位二进制(Java convert from decimal to 8-bit binary)我写了简单的java代码来从十进制转换为8位二进制:抱歉这个愚蠢的问题1 int dec=1;2 String result="";3 String reverse = "";4 while(dec!...
  • 二进制

    2020-02-16 21:31:04
    上面我们说了怎样使用晶体管做逻辑门,逻辑门可以判断布尔语句,布尔代数只有两个值:True和false。但是如果只有两个值我们怎样表达更多的东西?这个时候就需要二进制。...在二进制中一个1或者0叫一““,假如说一...
  • 2)二进制的简写形式二、进制运算1)进制运算表(1) 加法运算表(2)乘法运算表(3)进制简单运算题三、数据宽度1)什么是数据宽度2)计算机中常用的基本数据宽度四、无符号数有符号数进制进制也就是进位计数制,是人为...
  • 文章目录十进制转二进制的核心代码:方法一:直接使用列表逆序打印输出方法二:使用队列deque直接打印输出方法三:使用 divmod计算并用join连接字符串打印输出string.join(sequence ) 序列符号连接函数解释list[a :b...
  • 2、二进制进制 3、二进制和十六进制 4、十进制和进制或者十六进制 5、进制和十六进制 三、总结 一、概念 二进制为计算机存储的数字类型。即:逢2进1。0和1 十进制是通用的数字形式。即:逢10进1...
  • golang二进制字节的常用操作

    千次阅读 2018-08-24 21:34:36
    golang作为一热门的兼顾性能 效率的热门语言,相信很多人都知道,在编程语言排行榜上一直都是很亮眼,作为一门强类型语言,二进制位的操作肯定是避免不了的,数据的最小的单位也就是,尤其是网络中封包、拆包,...
  • 1、二进制进制: /*二进制进制*/ #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;math.h&amp;gt; #define MAXSIZE 20 #define ...
  • 二进制位运算符用于直接对二进制位进行计算,一共有7个。 二进制或运算符(or):符号为|,表示若两个二进制位都为0,则结果为0,否则为1。 二进制与运算符(and):符号为&amp;,表示若两个二进制位都为1,则...
  • 二进制 二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发...
  • 文章目录前言1、二进制1.1、二进制进制1.2、二进制转十进制1.2、二进制转十六进制2、进制1.1、进制转二进制1.2、进制转十进制1.2、进制转十六进制3、十进制3.1、十进制转二进制3.2、十进制转进制3.3、...
  • 21. 二进制位数组

    2020-06-08 16:14:10
    1)SETBIT:为位数组指定偏移量上的二进制位设置值,位数组的偏移量从0开始计数,而二进制位的值则可以为0或者1 2)GETBIT:获取位数组指定偏移量上的二进制位的值 3)BITCOUNT:统计位数组里面,值为1的二进制位...
  • 因为自带的方法在进行十六进制转为二进制的时候,精度在13字符后就会出现丢失,为了让精度不丢失就自己根据16进制转换2进制的原理写了两个两个方法 如果长度没有超过13,可以用parseInt("125adf8",...
  • 输入一个二进制数,将其快速转化为进制数。 输入描述 Input Description 一行,一个二进制数 输出描述 Output Description 二进制所对应的进制形式 样例输入 Sample Input 10001100 样例输出 Sample ...
  • 关于一个数的表示,我们常用的是十进制(人一般有十根手指嘛),另外也可以通过二进制进制、十六进制等表示数(可以相互转换),而计算机存储数始终采用的是二进制(逻辑电路中利用电的低电平表示 0 ,高电平...
  • 1、整数转二进制数 //将一个int型整数转换为二进制数 string itob(int number) { string binNum; while (number) { binNum += '0' + number%2; number /= 2; } reverse(binNum.begin(), binNum.end()); ...
  • 概述二进制位运算符用于直接对二进制位进行计算,一共有7个。二进制或运算符(or):符号为|,表示若两个二进制位都为0,则结果为0,否则为1。二进制与运算符(and):符号为&,表示若两个二进制位都为1,则结果为1...
  • /** * 将十进制转换成二进制进制、十六进制 ... * 3)、一个进制表示3个二进制位,最大值是7 * 4)、一个十六进制表示4个二进制位,最大值是15 * */ public class DecimalConvert { public stat
  • 什么是’次幂‘ 某数的次幂即为某数的次方,即某数与本身相乘*次 概念:2的0次幂是1 2的1次幂是2 2的2次幂是2✖2 2的3次幂是2✖2✖2 2的4次幂是2✖2✖2✖2 如10的5次幂=10✖10✖10✖...二进制和十进制里面0就是0,1就是
  • 二进制和十六进制

    千次阅读 2018-08-16 08:40:17
    不管用什么高级语言编写的程序最后都要转换为二进制语言,才能在计算机上执行,因此掌握二进制知识对学习编程语言是非常有帮助的。本篇和同学们探讨二进制计数原理以及与十进制、十六进制的转换。通过本篇的学习,你...
  • 计算机应用基础二进制.ppt ...二进制采用“逢二进一”,或“满2进1”即超过2时,会向高一进1,这样高一数就是低一位数的2倍。示 例 1001 1020 1111 3001 2222上面一组数中哪些是二进制数?( )2( )2示 例分、秒...
  • 1.什么是二进制 二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。当前的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 225,454
精华内容 90,181
关键字:

二进制超过8位