精华内容
下载资源
问答
  • 二进制数与十进制的相互转换、二进制数的乘除运算、移位运算
    千次阅读
    2020-04-17 11:11:28

    二进制数与十进制数的转换

    聊二进制数的运算前,我们先看看二进制数的值与十进制数的值是如何相互转换的,
    十进制转换成二进制
    将十进制数除以2,得到的商再除以2,依次类推直到商为1时为止,然后在旁边标出各步的余数,最后从下往上倒着写出来,高位补零就可以成功转换成二进制。
    例如下图49的二进制数就是110001
    在这里插入图片描述
    二进制转换成十进制
    只需将二进制数的各数位的值和位权相乘,然后将相乘的结果相加即可,有木有感觉特别方便。
    在这里插入图片描述
    二进制数的符号位
    二进制数中表示负数值时,一般会把最高位作为符号位来使用,最高位为0代表正数,最高位为1代表负数。
    这时了解二进制的人可能就会疑问,既然最高位1代表负数,1是00000001,那-1应该是10000001,为什么是11111111呢?要解释这个我们要先引入“补数”的概念,因为计算机在做加减运算时其实内部只会做加法运算,所以为了表示负数,就用正数来表示负数,这就是负数的概念。得到补数的方法很简单,进行取反操作,将二进制数的各位数的数值由1变为0,0变为1,再将结果加上1就可以了。

    00000001——————1(十进制)
    先进行取反操作,之后再加上1
    11111110
    变成
    11111111——————-1(十进制)

    不信的同学还可以验证以下,就会发现8位二进制的-1+1刚好等于100000000,而计算机会直接忽略掉最高位溢出的那个数字,所以刚好是00000000了。

    二进制数的乘除运算

    二进制数的乘除运算有两种方法,要么先转化位十进制数进行运算之后再转换为二进制(想来有点麻烦),要么头铁直接用二进制数进行乘除运算。

    在这里插入图片描述
    二进制数111乘以1011,乘数1011的每一位分别与乘数相乘,得到111、1110、00000、111000,将其加起来,得到1001101,这便是二进制乘法最直接的解求过程;也可以将111转化为十进制数7,1011转化为十进制数11,显版然7乘以11等于77,再将十进制数77化为二进制数1001101,显然1x26+1x23+1x22+1x20=64+8+4+1=77,所求结果完全正确。——百度

    二进制数的移位运算

    移位运算可是二进制的门面招牌
    在这里插入图片描述

    移位运算指的是将二进制数值的各数位进行左右移位(shift=移位)的运算。移位有左移(向高位方向)和右移(向低位方向)两种。在一次运算中,可以进行多个数位的移位操作。在程序代码中<<这个运算符表示左移,>>这个运算符表示右移,

    int a=1;
    int b;
    b=a<<3;//b现在为8

    运算符左侧是被移位的值,右侧表示要移位的位数。看到这有些同学就会想到,这移了几位不多了几个空白处么,计算机这千年老怪早想好了,如果是左移运算的话,它就会在空出来的低位补0。如果是右移运算的话,就稍微有点特殊,因为存在两种情况,既可以填1也可以填0,这就是逻辑右移和算数右移的区别。

    当二进制数的值表示图形模式而非数值时,移位后需要在最高位补0.类似于霓虹灯往右滚动的效果。这就称为逻辑右移。
    将二进制数作为带符号的数值进行运算时,移位后要在最高位填充移位前符号位的值(0或1)。这就称为算数右移。例如负数就在最高位补1,正数就在最高位补0。
    在这里插入图片描述

    更多相关内容
  • 二进制浮点数以及二进制浮点数算术运算二进制浮点数表示半精度浮点数单精度浮点数双精度浮点数特殊情况浮点数的运算步骤一、对阶二、尾数运算...判断六、例子二进制浮点数加法二进制浮点数减法浮点运算逻辑电路Reference...

    二进制浮点数表示

    在这里插入图片描述
    阶码(指数)就是指数位存储的值,而偏阶(移码)则不同精度的浮点数的偏阶也各不相同,具体可以查看指数偏差
    B i a s = 2 k − 1 − 1 Bias=2^{k-1}-1 Bias=2k11, 其中k是指数中的位数。

    半精度浮点数

    半精度浮点数 是一种被计算机使用的二进制浮点数据类型。半精度浮点数使用2个字节(16位)来存储。
    在IEEE 754-2008中,它被称作binary16。这种数据类型只适合存储对精度要求不高的数字,不适合用来计算。

    IEEE 754 标准指定了一个 binary16 要有如下的格式:
    Sign bit(符号位): 1 bit
    Exponent width(指数位宽): 5 bits
    Significand precision(尾数精度): 11 bits (有10位被显式存储)

    按如下顺序排列:
    在这里插入图片描述
    除非指数位全是0,否则就会假定隐藏的起始位是1。因此只有10位尾数在内存中被显示出来,而总精度是11位。据IEEE 754的说法,虽然尾数只有10位,但是尾数精度是11位的(log10(211) ≈ 3.311 十进制数).

    单精度浮点数

    单精度浮点数 格式是一种数据类型,在计算机存储器中占用4个字节(32 bits),利用“浮点”(浮动小数点)的方法,可以表示一个范围很大的数值。

    第1位表示正负,中间8位表示指数,后23位储存有效数位(有效数位是24位)。

    第一位的正负号0代表正,1代表负。

    中间八位共可表示 2 8 = 256 2^8=256 28=256个数,指数可以是二补码;或0到255,0到126代表-127到-1,127代表零,128-255代表1-128。

    有效数位最左手边的1并不会储存,因为它一定存在(二进制的第一个有效数字必定是1)。换言之,有效数位是24位,实际储存23位。

    在这里插入图片描述
    s i g n = + 1 sign = +1 sign=+1
    e x p o n e n t = ( − 127 ) + 124 = − 3 exponent = (-127)+124=-3 exponent=(127)+124=3
    f r a c t i o n = 1 + 2 − 2 = 1.25 fraction=1+2^{-2}=1.25 fraction=1+22=1.25
    v a l u e = ( + 1 ) × 1.25 × 2 − 3 = + 0.15625 value=(+1)\times1.25\times2^{-3}=+0.15625 value=(+1)×1.25×23=+0.15625

    双精度浮点数

    双精度浮点数(double)是计算机使用的一种资料类型。比起单精度浮点数,双精度浮点数(double)使用 64 位(8字节) 来存储一个浮点数。 它可以表示二进位制的53位有效数字,其可以表示的数字的绝对值范围为 [ 2 − 1024 , 2 1024 ] [2^{-1024}, 2^{1024}] [21024,21024]
    在这里插入图片描述

    特殊情况

    以双精度浮点数为例,说明一些特殊情况
    在这里插入图片描述

    当指数exponent全为0或者全为1时,有特殊含义,有以下四种情况,
    1、 e x p o n e n t = 0 , f r a c t i o n = 0 ⇒ ± 0 exponent=0, fraction=0 \Rightarrow \pm0 exponent=0,fraction=0±0
    2、 e x p o n e n t = 0 , f r a c t i o n ≠ 0 ⇒ 非 正 规 形 式 的 浮 点 数 exponent=0, fraction\neq0 \Rightarrow 非正规形式的浮点数 exponent=0,fraction=0
    3、 e x p o n e n t = 2047 , f r a c t i o n = 0 ⇒ ± ∞ exponent=2047, fraction=0 \Rightarrow \pm\infty exponent=2047,fraction=0±
    4、 e x p o n e n t = 2047 , f r a c t i o n ≠ 0 ⇒ N a N exponent=2047, fraction\neq0 \Rightarrow NaN exponent=2047,fraction=0NaN

    在这里插入图片描述

    浮点数的运算步骤

    浮点数的加减运算一般由以下五个步骤完成:对阶、尾数运算、规格化、舍入处理、溢出判断

    一、对阶

    所谓对阶是指将两个进行运算的浮点数的阶码对齐的操作。对阶的目的是为使两个浮点数的尾数能够进行加减运算。因为,当进行 M x ⋅ 2 E x M_x·2^{E_x} Mx2Ex M y ⋅ 2 E y M_y·2^{E_y} My2Ey加减运算时,只有使两浮点数的指数值部分相同,才能将相同的指数值作为公因数提出来,然后进行尾数的加减运算。对阶的具体方法是:首先求出两浮点数阶码的差,即 Δ E = E x − E y \Delta E = E_x - E_y ΔE=ExEy,将小阶码加上 Δ E \Delta E ΔE,使之与大阶码相等,同时将小阶码对应的浮点数的尾数右移相应位数,以保证该浮点数的值不变。几点注意:

    (1)对阶的原则是小阶对大阶,之所以这样做是因为若大阶对小阶,则尾数的数值部分的高位需移出,而小阶对大阶移出的是尾数的数值部分的低位,这样损失的精度更小。

    (2)若 Δ E \Delta E ΔE=0,说明两浮点数的阶码已经相同,无需再做对阶操作了。

    (3)采用补码表示的尾数右移时,符号位保持不变。

    (4)由于尾数右移时是将最低位移出,会损失一定的精度,为减少误差,可先保留若干移出的位,供以后舍入处理用。

    二、尾数运算

    尾数运算就是进行完成对阶后的尾数相加减。这里采用的就是我们前面讲过的纯小数的定点数加减运算。

    三、结果规格化

    在机器中,为保证浮点数表示的唯一性,浮点数在机器中都是以规格化形式存储的。对于IEEE754标准的浮点数来说,就是尾数必须是1.M的形式。由于在进行上述两个定点小数的尾数相加减运算后,尾数有可能是非规格化形式,为此必须进行规格化操作。

    规格化操作包括左规和右规两种情况。

    左规操作

    将尾数左移,同时阶码减值,直至尾数成为 1. M 1.M 1.M的形式。例如,浮点数 0.0011 ∗ 2 5 0.0011*2^5 0.001125是非规格化的形式,需进行左规操作,将其尾数左移3位,同时阶码减3,就变成 1.1100 ∗ 2 2 1.1100*2^2 1.110022规格化形式了。

    右规操作

    将尾数右移1位,同时阶码增1,便成为规格化的形式了。要注意的是,右规操作只需将尾数右移一位即可,这种情况出现在尾数的最高位(小数点前一位)运算时出现了进位,使尾数成为 10. x x x x 10.xxxx 10.xxxx 11. x x x x 11.xxxx 11.xxxx的形式。例如, 10.0011 ∗ 2 5 10.0011*2^5 10.001125右规一位后便成为 1.00011 ∗ 2 6 1.00011*2^6 1.0001126的规格化形式了。

    四、 舍入处理

    浮点运算在对阶或右规时,尾数需要右移,被右移出去的位会被丢掉,从而造成运算结果精度的损失。为了减少这种精度损失,可以将一定位数的移出位先保留起来,称为保护位,在规格化后用于舍入处理。

    IEEE754标准列出了四种可选的舍入处理方法:

    (1)就近舍入(round to nearest)这是标准列出的默认舍入方式,其含义相当于我们日常所说的“四舍五入”。例如,对于32位单精度浮点数来说,若超出可保存的23位的多余位大于等于 100 … 01 100…01 10001,则多余位的值超过了最低可表示位值的一半,这种情况下,舍入的方法是在尾数的最低有效位上加1;若多余位小于等于 011 … 11 011…11 01111,则直接舍去;若多余位为 100 … 00 100…00 10000,此时再判断尾数的最低有效位的值,若为0则直接舍去,若为1则再加1。

    (2) + ∞ +∞ +舍入(round toward + ∞ +∞ +)对正数来说,只要多余位不为全0,则向尾数最低有效位进1;对负数来说,则是简单地舍去。

    (3) − ∞ -∞ 舍入(round toward − ∞ -∞ )与朝 + ∞ +∞ +舍入方法正好相反,对正数来说,只是简单地舍去;对负数来说,只要多余位不为全0,则向尾数最低有效位进1。

    (4)朝0舍入(round toward 0)

    即简单地截断舍去,而不管多余位是什么值。这种方法实现简单,但容易形成累积误差,且舍入处理后的值总是向下偏差。

    五、 溢出判断

    与定点数运算不同的是,浮点数的溢出是以其运算结果的阶码的值是否产生溢出来判断的。若阶码的值超过了阶码所能表示的最大正数,则为上溢,进一步,若此时浮点数为正数,则为正上溢,记为 + ∞ +∞ +,若浮点数为负数,则为负上溢,记为 − ∞ -∞ ;若阶码的值超过了阶码所能表示的最小负数,则为下溢,进一步,若此时浮点数为正数,则为正下溢,若浮点数为负数,则为负下溢。正下溢和负下溢都作为0处理。

    要注意的是,浮点数的表示范围和补码表示的定点数的表示范围是有所不同的,定点数的表示范围是连续的,而浮点数的表示范围可能是不连续的。

    六、例子

    f l o a t      a = 0.3 ; b = 1.6 float \ \ \ \ a=0.3;b=1.6 float    a=0.3;b=1.6;

    a = ( 0.3 ) 10 = ( 0011   1110   1001   1001   1001   1001   1001   1010 ) 2 a=(0.3)_{10}=(0011\ 1110\ 1001\ 1001\ 1001\ 1001\ 1001\ 1010)_2 a=(0.3)10=(0011 1110 1001 1001 1001 1001 1001 1010)2
    S a = 0      E a = 011   1110   1      M a = 1.001   1001   1001   1001   1001   1010 S_a=0\ \ \ \ E_a=011\ 1110\ 1\ \ \ \ M_a=1.001\ 1001\ 1001\ 1001\ 1001\ 1010 Sa=0    Ea=011 1110 1    Ma=1.001 1001 1001 1001 1001 1010

    b = ( 1.6 ) 10 = ( 0011   1111   1100   1100   1100   1100   1100   1101 ) 2 b=(1.6)_{10}=(0011\ 1111\ 1100\ 1100\ 1100\ 1100\ 1100\ 1101)_2 b=(1.6)10=(0011 1111 1100 1100 1100 1100 1100 1101)2
    S b = 0      E b = 011   1111   1     M b = 1.100   1100   1100   1100   1100   1101 S_b=0\ \ \ \ E_b=011\ 1111\ 1\ \ \ M_b=1.100\ 1100\ 1100\ 1100\ 1100\ 1101 Sb=0    Eb=011 1111 1   Mb=1.100 1100 1100 1100 1100 1101

    a + b = ? a+b=? a+b=?

    二进制浮点数加法

    第一步:对阶

    ∵ E a < E b     E b − E a = 2 ∵ E_a < E_b\ \ \ E_b-E_a=2 Ea<Eb   EbEa=2

    ∴ M a 要 调 整 为 0.0   1001   1001   1001   1001   1001   10         10 ∴ Ma要调整为 0.0\ 1001\ 1001\ 1001\ 1001\ 1001\ 10\ \ \ \ \ \ \ 10 Ma0.0 1001 1001 1001 1001 1001 10       10

    E = 011    1111    1 E=011\ \ 1111\ \ 1 E=011  1111  1

    第二步:尾数运算

         0.01001100110011001100110 \ \ \ \ 0.01001100110011001100110     0.01001100110011001100110
    +   1.10011001100110011001101 +\ 1.10011001100110011001101 + 1.10011001100110011001101
    = 1.11100110011001100110011 =1.11100110011001100110011 =1.11100110011001100110011

    第三步:规格化

    1.11100110011001100110011 1.11100110011001100110011 1.11100110011001100110011‬已经是个规格化数据了

    第四步:舍入处理

    由于在对阶时, M a M_a Ma有右移,且第一次最高为1,第二次为0,所以按"0舍1入",尾数运算结果调整为 1.11100110011001100110100 1.11100110011001100110100 1.11100110011001100110100

    第五步:溢出判断

    没有溢出,阶码不调整,所以最后的结果为

    a + b = ( 0    01111111    11100110011001100110100 ) 2 = ( 0011   1111   1111   0011   0011   0011   0011   0100 ) 2 = ( 3 F F 33334 ) 16 a+b=(0\ \ 01111111\ \ 11100110011001100110100)_2=(0011\ 1111\ 1111\ 0011\ 0011\ 0011\ 0011\ 0100)_2=(3FF33334)_{16} a+b=(0  01111111  11100110011001100110100)2=(0011 1111 1111 0011 0011 0011 0011 0100)2=(3FF33334)16

    转为10进制

    a + b = 1.90000010 a+b=1.90000010 a+b=1.90000010

    二进制浮点数减法

    b − a = ? b-a=? ba=?
    第一步:对阶

    跟上面加法一样

    第二步:尾数运算

         1.10011001100110011001101 \ \ \ \ 1.10011001100110011001101     1.10011001100110011001101

    −   0.01001100110011001100110 -\ 0.01001100110011001100110  0.01001100110011001100110

    = 1.01001100110011001100111 =1.01001100110011001100111 =1.01001100110011001100111

    第三步:规格化

    1.01001100110011001100111 1.01001100110011001100111 1.01001100110011001100111已经是个规格化数据了

    第四步:舍入处理

    由于在对阶时, M a M_a Ma有右移,且第一次最高为1,第二次为0,所以按"0舍1入",尾数运算结果调整为 1.01001100110011001100110 1.01001100110011001100110 1.01001100110011001100110

    第五步:溢出判断

    没有溢出,阶码不调整,所以最后的结果为

    a − b = ( 0    01111111    01001100110011001100110 ) 2 = ( 0011    1111    1010    0110    0110    0110    0110    0110 ) 2 = ( 3 F A 66666 ) 16 a-b=(0\ \ 01111111\ \ 01001100110011001100110)2=(0011\ \ 1111\ \ 1010\ \ 0110\ \ 0110\ \ 0110\ \ 0110\ \ 0110)_2=(3FA66666)_{16} ab=(0  01111111  01001100110011001100110)2=(0011  1111  1010  0110  0110  0110  0110  0110)2=(3FA66666)16

    转为10进制

    a − b = 1.29999995 a-b=1.29999995 ab=1.29999995

    二进制浮点数乘法

    浮点数的乘法分为以下几个步骤:

    计算符号位:通过异或操作计算符号位,若两个操作数符号位相同,则结果符号位为0,否则结果符号为1
    计算原始尾数:两个操作数的尾数相乘(注意,这里是1.M * 1.M),得到原始尾数
    计算原始指数:将两个操作数的指数(这里指的是指数幂次方,也就是阶码-移码后得到的数)相加,得到原始指数
    规格化与舍入:对原始尾数和原始指数进行规格化,获得结果的指数,再对尾数进行舍入,获得结果的尾数

    f l o a t      X = − 0.3 ; Y = 500.25 float \ \ \ \ X=-0.3;Y=500.25 float    X=0.3;Y=500.25;

    X = ( − 0.3 ) 10 = ( 0.010011001100110011... 循 环 ) 2 = ( 1.00110011... 循 环 ) 2 ∗ 2 − 2 = ( 1    01111101    00110011001100110011010 ) 2 ( 这 里 对 无 限 循 环 小 数 有 舍 入 处 理 ) X=(-0.3)_{10}=(0.010011001100110011...循环)_{2}=(1.00110011...循环)_2 * 2^{-2}=(1\ \ 01111101\ \ 00110011001100110011010)_2(这里对无限循环小数有舍入处理) X=(0.3)10=(0.010011001100110011...)2=(1.00110011...)222=(1  01111101  00110011001100110011010)2()
    Y = ( 500.25 ) 10 = ( 111110100.01 ) 2 = ( 1.1111010001 ) 2 ∗ 2 8 = ( 0    10000111    11110100010000000000000 ) 2 Y=(500.25)_{10}=(111110100.01)_2=(1.1111010001)_2*2^{8}=(0\ \ 10000111\ \ 11110100010000000000000)_2 Y=(500.25)10=(111110100.01)2=(1.1111010001)228=(0  10000111  11110100010000000000000)2

    X ∗ Y = ( X s ∗ Y s ) ∗ 2 X E + Y E X*Y=(X_s*Y_s)*2^{X_E+Y_E} XY=(XsYs)2XE+YE
    X E = − 2             X s = 1.00110011001100110011010 X_E=-2\ \ \ \ \ \ \ \ \ \ \ X_s=1.00110011001100110011010 XE=2           Xs=1.00110011001100110011010
    Y E = 8                  Y s = 1.1111010001 Y_E=8\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Y_s=1.1111010001 YE=8                Ys=1.1111010001
       X s          1.0011001100110011001101 \ \ X_s\ \ \ \ \ \ \ \ 1.0011001100110011001101   Xs        1.0011001100110011001101
    ∗   Y s      ∗                          1.1111010001 *\ Y_s\ \ \ \ *\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 1.1111010001  Ys                            1.1111010001
    = 10.01011000010011001100111001011101 =10.01011000010011001100111001011101 =10.01011000010011001100111001011101

    X ∗ Y = 10.01011000010011001100111001011101 ∗ 2 6 X*Y=10.01011000010011001100111001011101*2^6 XY=10.0101100001001100110011100101110126
                 = 1.001011000010011001100111001011101 ∗ 2 7 ( 右 规 操 作 ) \ \ \ \ \ \ \ \ \ \ \ \ =1.001011000010011001100111001011101*2^7(右规操作)             =1.00101100001001100110011100101110127()

    结果二进制就为(注意,上面的指数7要加上移码才是存在指数位中的阶码,即7+127=134)
    ( 1    10000110    00101100001001100110100 ) 2 (1\ \ 10000110\ \ 00101100001001100110100)_2 (1  10000110  00101100001001100110100)2
    至于最后的尾数是怎么得到,是由原始尾数(X和Y的尾数相乘后得到)经过舍入得到

    二进制浮点数除法

    除法与乘法相差不大,变更为指数相减,尾数相除。

    f l o a t      X = 91.34375 ; Y = 0.14453125 float \ \ \ \ X=91.34375;Y=0.14453125 float    X=91.34375;Y=0.14453125;

    X = ( 91.34375 ) 10 = ( 1011011.01011 ) 2 = ( 1.01101101011 ) 2 ∗ 2 6 = ( 0    10000101    01101101011000000000000 ) 2 X=(91.34375)_{10}=(1011011.01011)_{2}=(1.01101101011)_2 * 2^{6}=(0\ \ 10000101\ \ 01101101011000000000000)_2 X=(91.34375)10=(1011011.01011)2=(1.01101101011)226=(0  10000101  01101101011000000000000)2
    Y = ( 0.14453125 ) 10 = ( 0.00100101 ) 2 = ( 1.00101 ) 2 ∗ 2 8 = ( 0    01111100    00101000000000000000000 ) 2 Y=(0.14453125)_{10}=(0.00100101)_2=(1.00101)_2*2^{8}=(0\ \ 01111100\ \ 00101000000000000000000)_2 Y=(0.14453125)10=(0.00100101)2=(1.00101)228=(0  01111100  00101000000000000000000)2

    X / Y = ( X s / Y s ) ∗ 2 X E − Y E = ( X s / Y s ) ∗ 2 6 − ( − 3 ) X/Y=(X_s/Y_s)*2^{X_E-Y_E}=(X_s/Y_s)*2^{6-(-3)} X/Y=(Xs/Ys)2XEYE=(Xs/Ys)26(3)
    X E = 6                   X s = 1.01101101011 X_E=6\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ X_s=1.01101101011 XE=6                 Xs=1.01101101011
    Y E = − 3                  Y s = 1.00101 Y_E=-3\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Y_s=1.00101 YE=3                Ys=1.00101
       X s          1.01101101011 \ \ X_s\ \ \ \ \ \ \ \ 1.01101101011   Xs        1.01101101011
    /   Y s      /    1.00101 /\ Y_s\ \ \ \ /\ \ 1.00101 / Ys    /  1.00101
    = 1.001111 =1.001111 =1.001111

    9 + 127 = 136 9+127 = 136 9+127=136

    ( 0    10001000    00111100000000000000000 ) 2 (0\ \ 10001000\ \ 00111100000000000000000)_2 (0  10001000  00111100000000000000000)2

    浮点运算逻辑电路

    在这里插入图片描述

    在这里插入图片描述

    Reference

    https://zhuanlan.zhihu.com/p/58731780
    https://www.yuejianzun.xyz/2019/05/28/%E6%B5%AE%E7%82%B9%E6%95%B0%E5%A4%84%E7%90%86/
    https://www.cnblogs.com/yilang/
    https://www.youtube.com/watch?v=MiOtePebraQ
    https://www.youtube.com/watch?v=27JjUa-eu_E&t=11s
    https://www.youtube.com/watch?v=fi8A4zz1d-s

    展开全文
  • Java中的二进制及基本的位运算二进制是计算技术中广泛采用的一数制。二进制数据是用0和1两个数码来表示的。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹...

    Java中的二进制及基本的位运算

    二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的基本上是二进制系统,数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关,用“开”来表示1,“关”来表示0。

    那么Java中的二进制又是怎么样的呢?让我们一起来揭开它神秘的面纱吧。

    一、Java内置的进制转换

    有关十进制转为二进制,和二进制转为十进制这种基本的运算方法这里就不展开讲了。

    在Java中内置了几个方法来帮助我们进行各种进制的转换。如下图所示(以Integer整形为例,其他类型雷同):

    a03a754a02d9b1b7658b0dce62b7dd15.png

    1,十进制转化为其他进制:1 二进制:Integer.toHexString(int i);

    2 八进制:Integer.toOctalString(int i);

    3 十六进制:Integer.toBinaryString(int i);

    2,其他进制转化为十进制:1 二进制:Integer.valueOf("0101",2).toString;

    2 八进制:Integer.valueOf("376",8).toString;

    3 十六进制:Integer.valueOf("FFFF",16).toString;

    3,使用Integer类中的parseInt()方法和valueOf()方法都可以将其他进制转化为10进制。

    不同的是parseInt()方法的返回值是int类型,而valueOf()返回值是Integer对象。

    二、基本的位运算

    二进制可以和十进制一样加减乘除,但是它还有更简便的运算方式就是——位运算。比如在计算机中int类型的大小是32bit,可以用32位的二进制数来表示,所以我们可以用位运算来对int类型的数值进行计算,当然你也可以用平常的方法来计算一些数据,这里我主要为大家介绍位运算的方法。我们会发现位运算有着普通运算方法不可比拟的力量。更多位运算应用请转移到我下篇博文《神奇的位运算》

    首先,看一下位运算的基本操作符:

    a42baa4888d4d38581db6bfd413cd949.png

    优点:

    特定情况下,计算方便,速度快,被支持面广

    如果用算数方法,速度慢,逻辑复杂

    位运算不限于一种语言,它是计算机的基本运算方法

    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    (一)按位与&

    两位全为1,结果才为1

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

    例如:51&5 即0011 0011 & 0000 0101 =0000 0001 因此51&5=1.

    特殊用法

    (1)清零。如果想将一个单元清零,即使其全部二进制位为0,只要与一个各位都是零的数值相与,结果为零。

    (2)取一个数中指定位。

    例如:设X=10101110,取X的低四位,用X&0000 1111=0000 1110即可得到。

    方法:找一个数,对应x要取的位,该数的对应位为1,其余位为零,此数与x进行“与运算”可以得到x中的指定位。

    (二)按位或 |

    只要有一个为1,结果就为1。

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

    例如:51|5 即0011 0011 | 0000 0101 =0011 0111 因此51|5=55

    特殊用法

    常用来对一个数据的某些位置1。

    方法:找到一个数,对应x要置1的位,该数的对应位为1,其余位为零。此数与x相或可使x中的某些位置1。

    (三)异或 ^

    两个相应位为“异”(值不同),则该位结果为1,否则为0

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

    例如:51^5 即0011 0011 ^ 0000 0101 =0011 0110 因此51^5=54

    特殊用法

    (1) 与1相异或,使特定位翻转

    方法:找一个数,对应X要翻转的位,该数的对应为1,其余位为零,此数与X对应位异或即可。

    例如:X=1010 1110,使X低四位翻转,用X^0000 1111=1010 0001即可得到。

    (2) 与0相异或,保留原值

    例如:X^0000 0000 =1010 1110

    (3)两个变量交换值

    1.借助第三个变量来实现

    C=A;A=B;B=C;

    2.利用加减法实现两个变量的交换

    A=A+B;B=A-B;A=A-B;

    3.用位异或运算来实现,也是效率最高的

    原理:一个数异或本身等于0 ;异或运算符合交换律

    A=A^B;B=A^B;A=A^B

    (四)取反与运算~

    对一个二进制数按位取反,即将0变为1,1变0

    ~1=0 ;~0=1

    (五)左移<<

    将一个运算对象的各二进制位全部左移若干位(左边的二进制位丢弃,右边补0)

    例如: 2<<1 =4 10<<1=100

    若左移时舍弃的高位不包含1,则每左移一位,相当于该数乘以2。

    例如:11(1011)<<2= 0010 1100=22

    11(00000000 00000000 00000000 1011)整形32bit

    (六)右移>>

    将一个数的各二进制位全部右移若干位,正数左补0,负数左补1,右边丢弃。若右移时舍高位不是1(即不是负数),操作数每右移一位,相当于该数除以2。

    左补0还是补1得看被移数是正还是负。

    例如:4>>2=4/2/2=1

    -14(即1111 0010)>>2 =1111 1100=-4

    (七)无符号右移运算>>>

    各个位向右移指定的位数,右移后左边空出的位用零来填充,移除右边的位被丢弃。

    例如:-14>>>2

    (即11111111 11111111 11111111 11110010)>>>2

    =(00111111 11111111 11111111 11111100)=1073741820

    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    上述提到的负数,他的二进制位表示和正数略有不同,所以在位运算的时候也与正数不同。

    负数以其正数的补码形式表示!

    以上述的-14为例,来简单阐述一下原码、反码和补码。

    原 码

    一个整数按照绝对值大小转化成的二进制数称为原码

    例如:00000000 00000000 00000000 00001110 是14的原码。

    反 码

    将二进制数按位取反,所得到的新二进制数称为原二进制数的反码。

    例如:将00000000 00000000 00000000 00001110 每一位取反,

    得11111111 11111111 11111111 11110001

    注意:这两者互为反码

    补 码

    反码加1称为补码11111111 11111111 11111111 11110001 +1=

    11111111 11111111 11111111 11110010

    现在我们得到-14的二进制表示,现在将它左移-14(11111111 11111111 11111111 11110010)<<2 =

    11111111 11111111 11111111 11001000

    =?

    分析:这个二进制的首位为1,说明是补码形式,现在我们要将补码转换为原码(它的正值)

    跟原码转换为补码相反,将补码转换为原码的步骤:

    补码减1得到反码:(11000111)前24位为1,此处省略

    反码取反得到原码(即该负数的正值)(00111000)

    计算正值,正值为56

    取正值的相反数,得到结果-56

    结论:-14<<2 = -56

    三、Java中进制运算

    Java中二进制用的多吗?

    平时开发中“进制转换”和“位操作”用的不多,Java处理的是高层。

    在跨平台中用的较多,如:文件读写,数据通信。

    来看一个场景:

    9235ddc30056be7fbeaf1eac41aca869.png

    如果客户机和服务器都是用Java语言写的程序,那么当客户机发送对象数据,我们就可以把要发送的数据序列化serializable,服务器端得到序列化的数据之后就可以反序列化,读出里面的对象数据。

    随着客户机访问量的增大,我们不考虑服务器的性能,其实一个可行的方案就是把服务器的Java语言改成C语言。

    C语言作为底层语言,反映速度都比Java语言要快,而此时如果客户端传递的还是序列化的数据,那么服务器端的C语言将无法解析,怎么办呢?我们可以把数据转为二进制(0,1),这样的话服务器就可以解析这些语言。

    f1ad2f472d928b8feebdf08a7d4f05fb.png

    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    Java中基本数据类型有以下四种:

    Int数据类型:byte(8bit,-128~127)、short(16bit)、int(32bit)、long(64bit)

    float数据类型:单精度(float,32bit ) 、双精度(double,64bit)

    boolean类型变量的取值有true、false(都是1bit)

    char数据类型:unicode字符,16bit

    对应的类类型:

    Integer、Float、Boolean、Character、Double、Short、Byte、Long

    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    (一)数据类型转为字节

    例如:int型8143(00000000 00000000 00011111 11001111)

    =>byte[] b=[-49,31,0,0]

    第一个(低端)字节:8143>>0*8 & 0xff=(11001111)=207(或有符号-49)

    第二个(低端)字节:8143>>1*8 &0xff=(00011111)=31

    第三个(低端)字节:8143>>2*8 &0xff=00000000=0

    第四个(低端)字节:8143>>3*8 &0xff=00000000=0

    我们注意到上面的(低端)是从右往左开始的,那什么是低端呢?我们从大小端的角度来说明。

    小端法(Little-Endian)

    低位字节排放在内存的低地址端即该值的起始地址,高位字节排位在内存的高地址端

    大端法(Big-Endian)

    高位字节排放在内存的低地址端即该值的起始地址,低位字节排位在内存的高地址端

    为什么会有大小端模式之分呢?

    这是因为在计算机系统中,我们是以字节为单位的,每个地址单元都对应着一个字节,一个字节为8bit。但是在C语言中除了8bit的char之外,还有16bit的short型,32bit的long型(要看具体的编译器),另外,对于位数大于8位的处理器,例如16位或者32位的处理器,由于寄存器宽度大于一个字节,那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x,在内存中的地址为0x0010,x的值为0x1122,那么0x11为高字节,0x22为低字节。对于大端模式,就将0x11放在低地址中,即0x0010中,0x22放在高地址中,即0x0011中。小端模式,刚好相反。我们常用的X86结构是小端模式,而KEIL C51则为大端模式。很多的ARM,DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

    例如:32bit的数0x12 34 56 78(十二进制)

    在Big-Endian模式CPU的存放方式(假设从地址0x4000开始存放)为

    内存地址

    0x4000

    0x4001

    0x4002

    0x4003

    存放内容

    0x78

    0x56

    0x34

    0x12

    在Little-Endian模式CPU的存放方式(假设从地址0x4000开始存放)为

    内存地址

    0x4000

    0x4001

    0x4002

    0x4003

    存放内容

    0x12

    0x34

    0x56

    0x78

    (二)字符串转化为字节

    1.字符串->字节数组1 String s;

    2 byte[] bs=s.getBytes();

    2.字节数组->字符串1 Byte[] bs=new byte[int];

    2 String s =new String(bs);或

    3 String s=new String(bs,encode);//encode指编码方式,如utf-8

    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    两种类型转化为字节的方法都介绍了,下面写个小例子检验一下:public class BtyeTest {

    /*

    * int整型转为byte字节

    */

    public static byte[] intTOBtyes(int in){

    byte[] arr=new byte[4];

    for(int i=0;i<4;i++){

    arr[i]=(byte)((in>>8*i) & 0xff);

    }

    return arr;

    }

    /*

    * byte字节转为int整型

    */

    public static int bytesToInt(byte[] arr){

    int sum=0;

    for(int i=0;i

    sum+=(int)(arr[i]&0xff)<<8*i;

    }

    return sum;

    }

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    byte[] arr=intTOBtyes(8143);

    for(byte b:arr){

    System.out.print(b+" ");

    }

    System.out.println();

    System.out.println(bytesToInt(arr));

    //字符串与字节数组

    String str="云开的立夏de博客园";

    byte[] barr=str.getBytes();

    String str2=new String(barr);

    System.out.println("字符串转为字节数组:");

    for(byte b:barr){

    System.out.print(b+" ");

    }

    System.out.println();

    System.out.println("字节数组换位字符串:"+str2);

    }

    }

    8bbea9ad629d4cc0163157bb1bd6645c.png

    展开全文
  • 二进制运算

    万次阅读 2017-12-03 20:00:01
    一,位运算基础 位运算(包括与,或,取反,异或,左移,右移等)是程序设计中的一个重要的领域。尤其是安全和底层开发中,除了指针的频繁使用之外,位运算是另...首先,我们必要复习一下C语言中位运算的一些基础计
    转载http://blog.csdn.net/u012713968/article/details/50481680
    一,位运算基础
    位运算(包括与,或,取反,异或,左移,右移等)是程序设计中的一个重要的领域。尤其是安全和底层开发中,除了指针的频繁使用之外,位运算是另一个非常频繁使用的领域。 因此,在求职面试中,位运算也是每年重点考查的知识点。首先,我们有必要复习一下C语言中位运算的一些基础计算方法。
     
    1,与运算:&

    与运算的操作符为&。2个数进行与运算时,就是将这2个数的二进制进行与操作, 只有当2个数对应的位都为1,该位运算结果为1,否则运算结果为0。即:1&1=1;1&0=0;0&0=0.
    比如计算15&10,首先15的二进制为:1111,10的二进制为1010(二进制,十进制和十六进制转化方法: 点击这里 ),所以15&10为:
    所以15&10=10。 

    2,或运算:|


    或运算的操作符为|。2个数进行或运算时,就是将这2个数的二进制进行或操作, 只要2个数对应的位有一个为1,该位运算结果为1,否则运算结果为0。即:1|1=1;1|0=1;0|0=0.
    比如计算15&10,首先15的二进制为:1111,10的二进制为1010,所以15|10为:
    所以15|10=15。 

    3,取反运算:~


    取反运算的操作符为~,为单目运算符。取反运算符顾名思义,就是将一个整数中位为1的变成0,位为0的变成1。即:~1=0;~0=1.
    比如计算~10,首先10的二进制为:1010,~10为:
    ~10=5。

     
    4,异或运算:^

    异或运算的操作符为^。2个数进行异或运算时,就是将这2个数的二进制进行异或操作, 只要2个数对应的位相同,该位运算结果为0,否则运算结果为1。即:1^1=0;1^0=1;0^0=0.
    比如计算15^10,首先15的二进制为:1111,10的二进制为1010,所以15^10为:
    所以15^10=5。

    5,右移运算符:>>

    右移运算符为>>。将一个数a向右移动n位记为:a>>n。比如将12向右移动2位如何计算呢?12的二进制为00001100,那么右移动2位为:00000011,即3。 即12>>2为3。 

    右移动运算分为两种右移,一种为逻辑右移,在移动过程中,左边位用0填充。一种为算术右移,在移动过程中,左边用符号位来填充。 比如对于有符号数:10000011,对于逻辑右移,向右移动3位,那么左边用0填充,变成了:00010000。而对于算术右移,向右移动3位,那么左边用1(1为符号位)填充,变成了11110000。而对于01000011,算术右移3位,那么左边用0(0为符号位)填充,变成了00001000。 在C语言中,右移运算符为算术右移运算符,即左边用符号位来填充。

    6,左移运算符:《

    左移运算符为《。将一个数a向左移动n位记为:a《n。 比如将12向左移动2位如何计算呢?12的二进制为00001100,那么左移动2位为:00110000。 无论左移还是右移,都需要用0或者1去填充移动之后空位。在左移的过程中,右边一律用0去填充。左移就没有右移那样分为逻辑右移和算术右移。 比如,将10左移2位,由于10的二进制为:00001010,那么左移2位,右边用零填充的结果为:00101000。 将一个数左移N位相当于将一个数乘以2^N,而将一个数右移N位相当于将这个数除以2^N。 

    位运算运算符的优先级如下:(优先级由高到低排列)
    而所有的C运算符的优先级与结合律如下图:(从图中可以看出,算术运算符的优先级高于《和》运算符)
    一些常见的二进制位的变换操作如下图:

    在实际的编程过程中,往往会用一个整数的不同位表示不同的数据信息。在访问该整数时,就需要通过位运算来获得或者改变整数的某几位数值。比如在Windows中创建文件时使用的Create数据结构: 
    struct 
    {
         PIO_SECURITY_CONTEXT SecurityContext; 
        ULONG Options; 
        USHORT POINTER_ALIGNMENT FileAttributes; 
        USHORT ShareAccess;
        ULONG POINTER_ALIGNMENT EaLength;
        PVOID EaBuffer; 
        LARGE_INTEGER AllocationSize;
     } Create; 
    通常会引用其中的Options如下: 
    Data->Iopb->Parameters.Create.Options 
    ULONG Options是一个Windows文件创建过程中的无符号长整数,指示在创建和打开文件时的不同选项。其中高8位指示了CreateDisposition参数(如FILE_OPEN,FILE_CREATE),低24位指示了CreateOptions参数(如FILE_DELETE_ON_CLOSE)。 为了得到CreateDisposition的值,采取下面的位操作:
     (Data->Iopb->Parameters.Create.Options >> 24) & 0x000000ff; 
    将该整数右移24位,再与0xff做与操作,即可获得CreateDisposition的值。
     

    二,位运算应用

    1.任何一个数和0异或是它的本身,和自身异或为0:

    a^0=a 
    a^a=0 
    利用上述性质,可以用来计算2个数的交换。
    大家应该知道,在计算机里,两个数互相交换,需要定义一个中间的变量来参与交换。如: 
    int tmp; 
    int a=10; 
    int b=20; 
    tmp=a; 
    a=b; 
    b=tmp; 
    上述代码计算之后,a和b的值完成交换,a的值为20,b的值为10。 
    如果用异或运算来交换2个数,可以如下方法: 
    int a=10; 
    int b=20; 
    a=a^b; 
    b=a^b; 
    a=a^b; 
    上述运行之后,a和b依然完成了值的交换,但由于是异或位运算,所以效率比上面的代码要高。 
    证明:
    a=10^20
    b=a^b=(10^20)^20=10^20^20=10^0=10
    a=a^b=10^20^10=10^10^20=0^20=20
    把上述代码,可以封装为一个交换2个数的函数如下: 
    void swap(int *a, int *b) 

        *a = *a ^ *b; 
        *b = *a ^ *b; 
        *a = *a ^ *b;
     }
     
    2.将整数的第n位置位或清零:

    #define BITN (1《n) 
    置位:a |= BITN; 
    清零:a &= ~BITN

    3.清除整数a最右边的1。

    方法:a & (a – 1)//该运算将会清除掉整数a二进制中最右边的1。 
    问题:如何判断判断整数x的二进制中含有多少个1? 
    分析:此题是微软公司的一道笔试题。下面用&运算来解决此题。 代码如下: 
    int func(int x ) 
    {
        int countx = 0; 
        while ( x ) 
        { 
            countx++; 
            x = x&(x-1); 
        } 
        return countx; 
    }
    4.用异或运算设计一个只有一个指针域的双向链表:

     

    提示: 
    要实现该设计要求,需要记住链表的头结点和尾结点,并在链表结点的的next域存放前一个结点和后一个结点的异或值。即: 
    p->next=pl^pr;//头结点的左边结点为NULL,尾结点的右边结点为NULL。 
    在遍历的时候,从头结点往右遍历的方法: 
    pl=NULL;
    p=Head; 
    while(p!=Tail) 

        pr=pl^(p->next); 
        pl=p; 
        p=pr;
     } 
    从尾结点往左遍历的方法: 
    pr=NULL; 
    p=Tail; 
    while(p!=Tail)

        pl=pr^(p->next); 
        pr=p; 
        p=pl; 


    5.计算下面表达式的值

    (char)(127<<1)+1
    (char)(-1>>1)+1
    1<<2+3

    解答:
    (char)(127<<1)+1=(01111111<<1)+1=11111110+1=11111111=-1
    (char)(-1>>1)+1=(11111111>>1)+1=11111111+1=0
    1<<2+3=1<<(2+3)=1<<5=2^5=32(注意《和+的优先级)
    展开全文
  • 2)二进制的简写形式二、进制运算1)八进制运算表(1) 加法运算表(2)乘法运算表(3)八进制简单运算题三、数据宽度1)什么是数据宽度2)计算机中常用的基本数据宽度四、无符号数有符号数进制进制也就是进位计数制,是人为...
  • 本文总结如何对数字进行进制转换与位运算
  • 关于一个的表示,我们常用的是十进制(人一般十根手指嘛),另外也可以通过二进制、八进制、十六进制等表示(可以相互转换),而计算机存储始终采用的是二进制逻辑电路中利用电的低电平表示 0 ,高电平...
  • 二进制的位运算

    千次阅读 2016-10-18 16:49:49
    二进制的位运算有哪些? (1).按位and运算& (2).按位or运算| (3).按位异或运算^ (4).取反运算~ (5).左移运算 (6).右移运算>>
  • 二进制,位运算(原码、反码、补码)

    千次阅读 2021-02-23 13:10:52
    1 二进制 2 原码、反码、补码 3 位运算符 4 位运算符使用技巧 上回学习运算符时,漏了位运算符,因为位运算符理解起来稍微有点复杂,所以要单独写一篇~ 要理解按位运算符,要先了解计算机进行存储和计算的底层逻辑。...
  • 二进制有符号数运算及溢出判别

    万次阅读 多人点赞 2019-09-02 16:32:19
    我的注解:上面例子都是补码相加,其中例7左边正数补码是其本身,右边负数补码取反加一,进位是两加每一位运算自身产生的进位。上面都是两个8bit相加,从左至右第一个bit位是符号位,第个bit位是最高数值位,...
  • 进制转换与位运算

    2021-05-23 06:09:16
    二进制“001”为例, 每一位都是一个bit。二进制只能由0/1组成,所以正好可以表示bit。什么是byte1个bit只能表示两信号或者两状态,表示的范围很小,例如英文字母26个就无法表示。所以规定8个bit一组作为一个...
  • 二进制是什么? 想要了解二进制数是如何表示...数字电子电路中,逻辑门的实现直接应用了二进制,因此现代的计算机和依赖计算机的设备里都用到二进制。每个数字称为一个比特(Bit,Binary digit的缩写)。——百...
  • 满意答案fyf68912352014.12.18采纳率:59%等级:10已帮助:5468人计算机中的所有信息都是以二进制方式表示的,这两个二进制数是0和1。电脑中存储的数字为采用二进制二进制是逢二进一,所有的都用两个数字0或1来...
  • 详解计算机内部存储数据的形式—二进制数 ...也就是说,只要掌握了使用二进制数来表示信息的方法及其运算机制,也就自然能够了解程序的运行机制了。那么,为什么计算机处理的信息要用二进制数来表示呢? ...
  • JS48 JS中的二进制运算和按位操作符

    千次阅读 2019-01-03 17:00:56
    JavaScript中的二进制运算 整数 JavaScript中,将十进制数字转换为二进制的方法是使用toString(2)方法,对于正整数的返回值是从不为零的首位开始返回: (8).toString(2); // 1000 对于负数,不会返回其真正的二进制...
  • 二进制加,减法,23个位运算技巧

    千次阅读 2019-04-06 20:36:22
    二进制加,减法 二进制最高位为1时表示负数,为0时表示正数。 **原码:**一个正数,转换为二进制位就是这个正数的原码。负数的绝对值转换成二进制位然后在高位补1就是这个负数的原码。 举例说明:  int类型的 3 的...
  • 二进制中的3位可以表示几种状态

    千次阅读 2021-07-06 01:21:06
    话题:二进制中的3位可以表示几种状态?问题详情:2.二进制中的3位可以表示()。 A)两种状态 B)四种状态 C)回答:C 二进制的一位只能表示两种状态,3位是2的3次方种状态了,这是史以来最垃圾的问题了! 分析打出来的是2...
  • 二进制:0,1 以0b或0B开头 十进制:0-9 八进制:0-7 以数字0开头 十六进制:0-9 及A(10)-F(15) ,以0x或0X开头,此处A-F不区分大小写 int n1 = 0b1010; int n2 = 1010; int n3 = 01010; int n4 = 0x1010; //...
  • 我们看一下刚才描述的状态: 一旦置R = 1,S = 0,S不变的情况下,无论R如何改变,Q都等于0 一旦置R = 0,S = 1,R不变的情况下,无论S如何改变,Q都等于1 我们观察后面加粗的句子,不难看出,1个二进制数被“锁在”...
  • 计算机进制、位运算

    2021-05-31 21:49:43
    一、进制转换 1、什么是进制 进制是数学中的一个概念,就是数据“逢进位...有二进制的原因是因为计算机最底层的电子元器件只有两状态——高电平和低电平(有电和没电)。任何数据在计算机中都是以二进制的形式存在
  • 1 在计算机中为什么使用二进制数在计算机中,广泛采用的是只有"0"和"1"两个基本符号...(2)二进制数用来表示的二进制数的编码、计数、加减运算规则简单。(3)二进制数的两个符号"1"和"0"正好与逻辑命题的两个值"是"和...
  • java中的二进制以及基本位运算

    万次阅读 多人点赞 2018-06-30 17:50:57
    二进制是计算技术中广泛采用的一数制。二进制数据是用0和1两个数码来表示的。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的...
  • 也就是说,只要掌握了使用二进制数来表示信息的方法及其运算机制,也就自然能够了解程序的运行机制了。那么,为什么计算机处理的信息要用二进制数来表示呢? 一、用二进制数表示计算机信息的原因 计算机内部是由  ...
  • 二进制是计算技术中广泛采用的一数制。二进制数据是用0和1两个数码来表示的。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的...
  • 二进制 二进制来自哲学,自然万物两两相对,白天与黑夜、太阳和月亮、苍天与大地、男人和女人、寒冷与炎热、甘甜和苦涩……我国传统文化中的阴阳学说、太极八卦,都是在讲这些自然的本质。 不光中国,在很久很久以前...
  • 1目前使用的大多数打印机是通过()接口与计算机连接的.A....存储程序控制原理3目前微机所用的总线标准多种,下面给出的四个缩写名中不属于描述总线标准的是()A.VGAB.USBC.ISAD.PCI4内存按工作原理可以分为()这几种...
  • 程序员二进制计算器 v1.36

    热门讨论 2014-07-16 16:21:43
    专为程序员打造的计算器,二进制运算强大,支持64位。 采用表达式驱动,输入表达式便即时显示结果,抛弃传统计算器繁琐的按钮,表达式可粘贴或回调重复使用。 支持二进制串直接运算,如0b1101 & 0b0011= 0b0001。 ...
  • 2、二进制

    2021-07-26 08:01:22
    IC是集成电路的简称,集成引脚电路只有0和5V使用二进制可以更好的控制电脑里面的电路位:位(bit,缩写为b)是存储器的最小单位,可以表示一位二进制数.字节:1字节(Byte,缩写为B)由8个位组成,即1Byte=8bit,是...
  • “异或”的数学运算符表示为“⊕”,“同或”的数学...在数学中异或和同或常用于命题的判断,而在计算机中则常用于二进制数之间的运算, 异或运算 关于异或运算有以下的规定: 0⊕0=0 0同0异或,结果为0 0⊕1=..
  • 用汇编实现二进制数和十六进制的相互转换

    千次阅读 多人点赞 2020-08-03 16:50:13
    用汇编实现二进制数向十六进制的转换 一、实现功能 1)实现二进制数向十六进制的转换 2)实现十六进制二进制数的转换‘ 二、设计分析       汇编语言中,字符在机器中都是以ascii码的二进制...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,964
精华内容 34,785
关键字:

二进制数的逻辑运算有几种