精华内容
下载资源
问答
  • 十六进制 --> 十进制–> 二进制 转换过程 A(十六进制) = 1010(二进制)=10(十进制) B(十六进制) = 1011(...十六进制转换有16进制每一位上可以是从小到大为01、2、3、4、5、6、7、8、9、A、B、C、D、E、F16个

    十六进制 --> 十进制–> 二进制 转换过程

    A(十六进制) = 1010(二进制)=10(十进制)

    B(十六进制) = 1011(二进制)=11(十进制)

    C(十六进制) = 1100(二进制)=12(十进制)

    D(十六进制) = 1101(二进制)=13(十进制)

    E(十六进制) = 1110(二进制)=14(十进制)

    F(十六进制) = 1111(二进制)=15(十进制)

    十六进制转换有16进制每一位上可以是从小到大为0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F16个大小不同的数,即逢16进1,其中用A,B,C,D,E,F(字母使用大写)这六个字母来分别表示10,11,12,13,14,15。

    1、十六进制转十进制:

    十六进制数的第0位的权值为16的0次方,第1位的权值为16的1次方,第2位的权值为16的2次方……
    所以,在第N(N从0开始)位上,如果是是数 X (X 大于等于0,并且X小于等于 15,即:F)表示的大小为 X*16的N次方。
    
    如:1FA4 = 1*16^3+15*16^2+10*16^1+4*16^0 =  8100
    

    2、十进制转二进制:

    十进制整数转换bai为二进制整数采用"除2取余,逆序排列"法。
    

    在这里插入图片描述

    3、二进制转十六进制

    16进制就有16个数,0~15,用二进制表示15的方法就是1111,从而可以推断出,16进制用2进制可以表现成0000~1111,顾名思义,也就是每四个为一位。举例:
    

    在这里插入图片描述

    4、小数转换可以看看下面的文章

    二进制十进制间小数互转(二)

    以上就是各个转换,希望有帮助,常用才能熟练。

    展开全文
  • 重要声明:本文章仅仅代表了作者个人对此观点的理解表述。读者请查阅时持自己的意见进行讨论。 本文原文来自 《二进制的认识Java二进制的使用》。...二进制数据是用0和1两个数码来表示的...

    重要声明:本文章仅仅代表了作者个人对此观点的理解和表述。读者请查阅时持自己的意见进行讨论。

    本文原文来自 《二进制的认识和Java中对二进制的使用》

    本文的讲解及代码部分都是针对Java语言,可能对其它语言并不适用,但介于这部分内容较底层,因此可酌情参考。

    一、认识二进制

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

    二、位 - bit

    计算机能保存的最小数据单位:位(bit),常常也叫:比特。一个位保存的数据,要么是0,要么是1

    由于一个位的数据存储量太少,因此大多数情况下都是几个位组成多个来使用。下面就是常见的基本类型定义:

    • byte: 由8个位组成。
    • short: 由16个位组成
    • char: 由16个位组成
    • int: 由32个位组成
    • float: 由32个位组成
    • long: 由64个位组成
    • double: 由64个位组成

    同时 byteshortintlong (即整数)在保存数据时,高位表示符号位,用1表示负数,用0表示正数。所谓最高位,就是从左数的第一位。当表示负数时,实际值要对所有位取反然后加1。比如:

    使用byte作为案例,因为只有8位,篇幅占用少。
    
    00000010: 表示整数 2
    11111110: 表示整数 -2。
              取值过程:
              第一步:观察最高位是1,因此取反,得:00000001
              第二步:取反后加1,得:00000010
              得出结果:2,取负得:-2。
    
    为了直观观察,常常每4位写一个空格:
    0000 0010 = 2
    1111 1110 = -2
    

    1、二进制转十进制

    二进制十分不便于阅读,而十进制是从小就接触到的。所以,将二进制数据转换为十进制经常用到各种场合。甚至大多数情况下,都是将数据转换为十进制进行使用。

    先从简单开始,首先来说说十进制:

    十进制的基数是:0, 1, 2, 3, 4, 5, 6, 7, 8, 9
    当我们数数时,数到第十时,由于基数里没有一个数字可以直接表示十这个数,所以产生了进位,到第九时,若要继续数下去,那么就进一位,从而变成:10。使用了基数 1 和基数 0 组合起来,形成 10。
    
    同样的道理,二进制的基数是:0, 1
    当我们数数时,数到二时,由于基数里没有一个数可以直接表示二这个数,所以也要进位。那么进一位后就形成了:10。
    
    那么,不妨来多罗列几个数字,形成直观的感受:
    二进制   十进制
       1  ==   1
      10  ==   2
      11  ==   3
     100  ==   4
     101  ==   5
     110  ==   6
     111  ==   7
    1000  ==   8
    1001  ==   9
    1010  ==  10
    1011  ==  11
    1100  ==  12
    1101  ==  13
    1110  ==  14
    1111  ==  15
    

    数字简单的话,可以通过一个一个的数数,直接反应出结果,但如果有一个很长的二进制数,用数数的方法显然也没法快速完成了,我们必须使用一套计算方法来完成这个工作了,先来看一张图:

    图1

    按照图上的公式,计算出接过来,就可以得到十进制的结果了。

    2、十进制转二进制

    有了上面一小节的知识后,就很容易理解各进制间的关系了。那么从十进制转换为二进制又该如何转换呢,这节知识应该在高中时就有所学习了:

    图2

    使用图上的计算方式,每次除以2,然后取余数,最终商为0时停止计算,上图中:215的二进制表示为:11010111。

    三、字节 - byte

    一个字节由8个位组成,因此他能容纳的整数范围也就被框定在了:[-128, 127] 之间,为什么在这个范围之间?不妨看看下面的推理过程:

    一个byte占8位,而最高位0表示正数,1表示负数。
    因此不难得出最小值:1000 0000, 最大值:0111 1111
    
    最小值:1000 0000。将实际值计算出来:
    1、最高位是1,为负数,先取反得:0111 1111;
    2、再加1得:1000 0000;
    3、使用上面的公式计算:1x(2^7)+0x(2^6)+...+0x(2^0) = 128
    4、由于最高位是1,表示负数,得到最终结果:-128
    
    最大值:0111 1111。将实际值计算出来:
    1、直接使用公式计算:1x(2^6)+1x(2^5)+...+1x(2^0) = 127
    2、由于最高位是0,直接确定最终结果:127
    
    所以为什么byte的容量只能在: [-128, 127] 子间,这就是原因所在了。
    

    阅读了上面的推导过程,细心的朋友不难发现,当最大值再进行加1操作过后,其结果在二进制层面上立刻就变成了最小值,再反应到十进制输出时,就直接成了: 127 + 1 = -128 这样的非常规结果了。主要原因就在于,byte最大值就是127,而再进行加1,最高位就变成了1,立刻就发生了质的变法,从正数变成了负数,还不小心成了byte里最小的负数。(实际上127+1赋值给byte是会报错的,但如果你把128通过强制转换成byte,则会出现此问题。)

    四、短整型 - short

    在实际编程过程中,并不经常用到它,可能比较重要的一个原因就是它能容纳的数据不大。但即便是不大,它也比字节(byte)多占用1倍的空间。短整型占用了 16 个位,也就相当于 2 个字节的容量。因此不难得到它的最大最小范围:1000 0000 0000 0000 ~ 0111 1111 1111 1111,写出十进制值则是:
    -32768 ~ 32767。计算过程可以按照上一节的方式计算出来。

    五、整型 - int

    整型是实际编程过程中最常用的基本类型之一,它由 32 个位组成,显然能存储的数字就更大。它的取值范围是:-2147483648 ~ 2147483647‬ 。 这个容量对于大多数场景来说,都已经适用了。

    六、长整型 - long

    长整型的数据存储容量又是整型的2倍,它由 64 个位组成。取值范围是:-9223372036854775808 ~ 9223372036854775807

    七、浮点

    浮点类型的数据可以支持小数点在内,这样一来就为程序里支持小数点提供了解决方案。不过它不是精确表示的,意味着在有时候得到的结果可能并不是一个精确的数字。java针对浮点类型数在内存里的保存方式是遵循了 IEEE 754标准 的。因此,要了解浮点数是如何保存的,只需要了解这个标准是如何制定的就知道了。同时下面也会对其做详细的介绍。

    1、十进制小数与二进制的互换

    在开始了解浮点数前,有必要先了解一下十进制小数是怎么和二进制进行转换的。对于十进制小数的转换为二进制,需要分为两部分处理,整数部分和小数部分。

    1)、十进制->二进制

    例如我将:24.13 转换为二进制。

    整数部分

    整数部分也就是小数点左边部分,是:24。可以直接使用上边几节的知识将其进行转化为二进制,为节省篇幅,此处直接得出结果:11000

    小数部分

    小数部分也就是小数点右边部分,是:0.13。我们知道,整数部分转换为二进制是使用除法取余,最终倒序取结果的方式。而针对小数部分,就不是这样计算的了,甚至计算方式相反,要进行乘法运算了。小数部分转化二进制,常常采用乘2取整的方法。就是将小数部分乘以2,得到的结果取其整数部分。例如将0.13转化为二进制:

    // 只对小数部分乘2取整。
    0.13 × 2 = 0.26 -> 取整数部分得:0 ,下次计算只使用小数部分:0.26
    0.26 × 2 = 0.52 -> 取整数部分得:0 ,下次计算只使用小数部分:0.52
    0.52 × 2 = 1.04 -> 取整数部分得:1 ,下次计算只使用小数部分:0.04
    0.04 × 2 = 0.08 -> 取整数部分得:0 ,下次计算只使用小数部分:0.08
    0.08 × 2 = 0.16 -> 取整数部分得:0 ,下次计算只使用小数部分:0.16
    0.16 × 2 = 0.32 -> 取整数部分得:0 ,下次计算只使用小数部分:0.32
    0.32 × 2 = 0.64 -> 取整数部分得:0 ,下次计算只使用小数部分:0.64
    0.64 × 2 = 1.28 -> 取整数部分得:1 ,下次计算只使用小数部分:0.28
    0.28 × 2 = 0.56 -> 取整数部分得:0 ,下次计算只使用小数部分:0.56
    0.56 × 2 = 1.12 -> 取整数部分得:1 ,下次计算只使用小数部分:0.12
    0.12 × 2 = 0.24 -> 取整数部分得:0 ,下次计算只使用小数部分:0.24
    0.24 × 2 = 0.48 -> 取整数部分得:0 ,下次计算只使用小数部分:0.48
    0.48 × 2 = 0.96 -> 取整数部分得:0 ,下次计算只使用小数部分:0.96
    0.96 × 2 = 1.92 -> 取整数部分得:1 ,下次计算只使用小数部分:0.92
    0.92 × 2 = 1.84 -> 取整数部分得:1 ,下次计算只使用小数部分:0.84
    0.84 × 2 = 1.68 -> 取整数部分得:1 ,下次计算只使用小数部分:0.68
    0.68 × 2 = 1.36 -> 取整数部分得:1 ,下次计算只使用小数部分:0.36
    0.36 × 2 = 0.72 -> 取整数部分得:0 ,下次计算只使用小数部分:0.72
    0.72 × 2 = 1.44 -> 取整数部分得:1 ,下次计算只使用小数部分:0.44
    0.44 × 2 = 0.88 -> 取整数部分得:0 ,下次计算只使用小数部分:0.88
    0.88 × 2 = 1.76 -> 取整数部分得:1 ,下次计算只使用小数部分:0.76
    0.76 × 2 = 1.52 -> 取整数部分得:1 ,下次计算只使用小数部分:0.52
    0.52 × 2 = ....... 发现又一次出现0.52,这和第4行的产生了重复,继续乘下去也会一直这样下去,这里就产生了二进制上的循环。
    
    那么此时,可得到小数(为了显示清晰,在循环部分我使用空格分开):
    0.13 转化为二进制为:00 10000101000111101011 10000101000111101011....循环
    

    拿到了小数部分的二进制结果,再加上整数部分的二进制结果就得到了:

    24.13 = 11000.00 10000101000111101011 10000101000111101011....循环
    
    2)、二进制->十进制

    在上边的讲解 位(bit) 的小节阐述了如何将二进制数据直接转化为十进制,你可以使用同样的方法将带小数的二进制数据代入公式进行计算。就拿上边得到的结果来进行运算

    整数部分

    整数部分十分简单,可直接套入公式:

    11000 = 1×(2^4)+1×(2^3)+0×(2^2)+0×(2^1)+0×(2^0) = 24
    

    小数部分

    或许你会对小数部分感到迷惑,实际上知道真相的你眼泪会掉下来。在上面整数计算过程中,其指数部分由高到低分别降低: 4-3-2-1-0,而小数部分,可以继续降低,然后使用同样的方法:

    00 10000101000111101011 10000101000111101011....循环 = 0×(2^-1)+0×(2^-2)+1×(2^-3)+0×(2^-4)+0×(2^-5)+0×(2^-6)+0×(2^-7)+1×(2^-8)++0×(2^-9)+1×(2^-10)+0×(2^-11).... ≈0.13
    

    最终整数部分加上小数部分的结果,即可顺利得到最终结果:

    11000.00 10000101000111101011....循环 = 1×(2^4)+1×(2^3)+0×(2^2)+0×(2^1)+0×(2^0)+0×(2^-1)+0×(2^-2)+1×(2^-3)+0×(2^-4)+0×(2^-5)+0×(2^-6)+0×(2^-7)+1×(2^-8)++0×(2^-9)+1×(2^-10)+0×(2^-11).... ≈ 24.13
    

    从这样一个计算过程,也不难发现,在处理小数的保存时,精度问题也逐渐的暴露了出来。

    2、单精度浮点 - float

    单精度浮点数占用32个位空间,它和整型(int)占用相同数量的空间。但它的取值范围计算方式和整型(int)的取值范围计算方式大不一样。由于浮点数在计算机中的保存方式和整型的保存方式不一样,从而导致了它们的取值范围不一样。java对浮点数的保存方式遵循了 IEEE 754标准 标准。在了解单精度浮点的范围之前,不妨先来一窥 IEEE 754标准 的真面目。

    IEEE 754 标准

    IEEE二进制浮点数算术标准(IEEE 754)是20世纪80年代以来最广泛使用的浮点数运算标准,为许多CPU与浮点运算器所采用。这个标准定义了表示浮点数的格式(包括负零-0)与反常值(denormal number)),一些特殊数值(无穷(Inf)与非数值(NaN)),以及这些数值的“浮点数运算符”;它也指明了四种数值舍入规则和五种例外状况(包括例外发生的时机与处理方式)。了解更多

    标准什么的看起来可能会比较难以理解,不如先看一下这张图来入个门吧:

    图1

    符号位

    只占用第一个位,这个很容易理解,它的作用就是确定这个数是负数还是正数。这个整数类型首位符号位是一个意思。

    指数部分

    占用了接下来的8个位,这部分保存了指数部分的值,需先将十进制小数转化为二进制小数,然后转化成二进制科学计数法的小数,然后将其指数部分加上偏移(127)再保存到指数部分。例如:

    比如我们将小数 13.625 的指数部分要保存的值求出来:
    第一步 - 先化十进制小数为二进制,根据上面的知识,很容易得到:1101.101
    第二步 - 化二进制结果为科学计数法。
          要注意这个过程有个规定:化为科学计数法时必须要保证小数点左边只有一个数并且这个数只能是1。
          因此这里我们只需要将 1101.101 向右移动(即小数点向左)3个位置,就可得到结果:1.101101 × 2^3
    第三步 - 将指数实际值加上偏移127。得:3 + 127 = 130
    第四步 - 计算 130 的二进制结果,按照上面的知识即可技术得到结果:1000 0010
    
    最终,我们拿到小数 13.625 的指数部分要保存到计算机的结果:1000 0010
    

    底数部分

    这部分占用了剩下的所有23个位。它负责保存底数部分,就比如上面的推导过程中,二进制科学计数法时,其数据的底数就是 1.101101,而规定了小数点左边只能是1,因此保存时只保存小数点右边部分 101101,这个数据量还没有达到 23 个,可在后面补0直到23个。例如:

    接上一部分推导。我们已经拿到了 13.625 的二进制科学计数表示结果:1.101101 × 2^3
    第一步 - 取底数:1.101101
    第二部 - 左边始终为1,只需保存小数点右边部分:101101
    第三步 - 不足23位,补0。
    最终得到底数部分要保存的值:101101 000000 000000 00000
    

    最后,再结合符号位指数部分底数部分,将小数 13.625 保存到计算机的完整结果:

    小数:13.625
    入计算机:0 10000010 10110100000000000000000
    

    3、单精度浮点 - float - 取值范围

    那么有了这些了解之后,就很容易得出单精度浮点数的最小值和最大值了 1 11111111 11111111111111111111111 ~ 0 11111111 11111111111111111111111。现在不妨来计算一下它们的十进制值:

    先计算最小值:1 11111111 11111111111111111111111
    第一步 - 确定正负。观察首位是1,表示负数。
    第二步 - 计算指数。指数位: 11111111
          将二进制数:11111111 转化为十进制得:255
          由于存入时的指数是加了偏移127的,因此取出时要减去,得: 255-127 = 128
    第三步 - 计算底数。底数为:11111111111111111111111
          由于底数存储是使用的小数点右边部分,因此取出是要加上原本左边的[1.]。
          得到结果:1.11111111111111111111111
    第四步 - 拼接为科学二进制计数法。
          将底数和指数结合,得:1.11111111111111111111111 × 2^(128)
    第五步 - 转为二进制常规计数法。
          得到:1 11111111111111111111111 00...00 (除第一个1外,有23个1。共104个0)
    第六步 - 将此二进制数计算为十进制。
          1×(2^127) + 1×(2^126) + ... + 1×(2^104) + 0×(2^103) + ... + 0×(2^0)
          = 340282346638528859811704183484516925440
    第七步 - 取负值。应为原始二进制数据首位是1,因此取负值。
    最终得到 float 最小值为:-340282346638528859811704183484516925440
    
    针对最大值的计算,其实计算方式相同。只是首位正负不同而已。
    那么最终可得到float的十进制取值范围:
    -340282346638528859811704183484516925440 ~ 340282346638528859811704183484516925440
    

    4、双精度浮点 - double

    双精度浮点占用了 64 个位,它与单精度浮点数在数据存入计算机时是使用相同的原理。只是数据量大小的区别。区别如下:

    区域单精度(float)双精度(double)
    符号位占1位占1位
    指数位占8位占11位
    指数位偏移值1271023
    底数位23位52位

    八、字符 - char

    字符(char)占用了16个位,它在内存中实际上保存的是字符对应的ASCII码值,而该值就是一个整型数据,因此其存储逻辑和整型数据是一致的,只是在读取时,会根据ASCII码表进行对应转换。常见的ASCII字符码值如下:

    字符码值字符码值字符码值
    0\t9\n10
    \r13空格32
    !33"34#35
    $36%37&38
    39(40)41
    *42+43,44
    -45.46/47
    048149250
    351452553
    654755856
    957:58;59
    <60=61>62
    ?63@64A65
    B66C67D68
    E69F70G71
    H72I73J74
    K75L76M77
    N78O79P80
    Q81R82S83
    T84U85V86
    W87X88Y89
    Z90[91|92
    ]93^94_95
    `96a97b98
    c99d100e101
    f102g103h104
    i105j106k107
    l108m109n110
    o111p112q113
    r114s115t116
    u117v118w119
    x120y121z122
    {123|124}125
    ~126

    你可以使用这段代码把所有字符打印出来:

    for (char i = 0; i < Character.MAX_VALUE; i++) {
        System.out.println(i + ":" + (short)i);
    }
    
    展开全文
  • 二进制中1的个数

    2017-04-25 15:44:23
    输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。首先要理解这个题考点不是要你怎么去表示原码、补码、反码之类的。在计算机正数的表示就是他的原码,负数的表示就是他的补码。至于这几个码到底...

    输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。

    首先要理解这个题考点不是要你怎么去表示原码、补码、反码之类的。在计算机中正数的表示就是他的原码,负数的表示就是他的补码。至于这几个码到底是怎么样的,后面再讲。

    举例子,6的二进制表示为0000 0110(一般都是用8位表示原码)。6-1,二进制的表示为:0000 0110 - 0000 0001,这个时候,遇到0000 0110从右到左,第一个不为0的位,将其变为0,而这个位右边的全部变为1,也就是0000 0101。然后将0000 0101 与6 的原码进行“与”运算,即 0000 0101 & 0000 0110,得到0000 0100,这样进行一次之后就将6的原码的最右边的1变为了0。按照这个思想,我们一直进行此过程,直到n等于0。

    综上分析,代码为:

    public class Solution {
        public int NumberOf1(int n) {
            if(n == 0){
                return 0;
            }
            int countOfOne = 0;
            while(n != 0){
                n = n & (n - 1);
                countOfOne ++ ;
    
            }
            return countOfOne;
        }
    }

    所谓原码就是机器数,是加了一位符号位的二进制数,正数符号位为0,负数符号位为1,计算机中存储、处理、运算的数据通常是8位、16位、32位或64位的。
    这里以最简单的8位为例讲解。注意符号位是包含在8位中的其中1位,故可直观读出的数只有7位(只有后7位数可以按权展开)。有心人可能注意到原码是有缺陷的,它只能表示255种状态,因为00000000(+0)和10000000(-0)其实是一个数,因此原码的表示范围成了-127到+127,这个问题需要神奇的补码来解决,因为在补码中10000000被用来表示-128。
    所谓反码,英语里又叫ones’ complement(对1求补),这里的1,本质上是一个有限位计数系统里所能表示出的最大值,在8位二进制里就是11111111,在1位十进制里就是9,在3位十六进制里就是FFF(再大就要进位了)。求反又被称为对一求补,用最大数减去一个数就能得到它的反,很容易看出在二进制里11111111减去任何数结果都是把这个数按位取反,0变1,1变零,所以才称之为反码。用原码求反码的方法是,正数不变,负数保留符号位1不变,剩下位按位取反。
    所谓补码,英语里又叫two’s complement(对2求补),这个2指的是计数系统的容量(模),就是计数系统所能表示的状态数。对1位二进制数来说只有0和1两种状态,所以模是10也就是十进制的2,对7位二进制数来说就是10000000,这个模是不可能取到的,因为位数多一位。用模减去一个数(无符号部分)就能得到这个数的补,比如10000000-1010010=0101110,事实上因为10000000=1111111+1,稍加改变就成了(1111111-1010010)+1,所以又可以表述为先求反再加1。总结求补码的方法就是正数依旧不变,负数保留符号位不变,先求反码再加上1。记住了怎么求补码,接下来讲讲运算。通过原码的符号位和数值,我们能迅速指出它代表的数,判断其正负并进行四则运算,相比而言反码和补码对于人则显得过于晦涩。如果说原码是给人看的数字语言,那么补码就是计算机的数字语言。计算机不需要知道什么是正负、大小,这些判断对它而言过于复杂。事实上它存储、处理、传输的数都只有补码一种形式,人所做的加减乘除,在计算机里只通过相加和移位就能解决,这都来自于补码系统的内在自洽和巧夺天工的神奇魔力,也是后文要阐述的重点。
    这里我是引用了引用了知乎网友的回答,更为详细的请参考这篇帖子:知乎:原码、反码、补码

    展开全文
  • 转成二进制主要有以下几种:正整数转二进制,负整数转二进制,小数转二进制1、 正整数转成二进制。要点一定一定要记住哈:除二取余,然后倒序排列,高位补零。 也就是说,将正的十进制数除以二,得到的商再...
    1.  转成二进制主要有以下几种:正整数转二进制,负整数转二进制,小数转二进制;

      1、  正整数转成二进制。要点一定一定要记住哈:除二取余,然后倒序排列,高位补零。

              也就是说,将正的十进制数除以二,得到的商再除以二,依次类推知道商为零或一时为止,然后在旁边标出各步的余数,最后倒着写出来,高位补零就OK咧。哎呀,还是举例说明吧,比如42转换为二进制,如图1所示操作。

    2.  

              42除以2得到的余数分别为010101,然后咱们倒着排一下,42所对应二进制就是101010.如图2所示更直观的表达。

    3.  

              计算机内部表示数的字节单位是定长的,如8位,16位,或32位。所以,位数不够时,高位补零,所说,如图3所示,42转换成二进制以后就是。00101010,也即规范的写法为(42)10=(00101010)2.赶紧记住吧。

    4.  

      2、  负整数转换成二进制

              方法:先是将对应的正整数转换成二进制后,对二进制取反,然后对结果再加一。还以42为例,负整数就是-42,如图4所示为方法解释。最后即为:(-42)10=(11010110)2.

    5.  

      3、  小数转换为二进制的方法:对小数点以后的数乘以2,有一个结果吧,取结果的整数部分(不是1就是0喽),然后再用小数部分再乘以2,再取结果的整数部分……以此类推,直到小数部分为0或者位数已经够了就OK了。然后把取的整数部分按先后次序排列就OK了,就构成了二进制小数部分的序列,举个例子吧,比如0.125,如图5所示。

    6.  

              如果小数的整数部分有大于0的整数时该如何转换呢?如以上整数转换成二进制,小数转换成二进制,然后加在一起就OK了,如图6所示。

    7.  

      4、  整数二进制转换为十进制:首先将二进制数补齐位数,首位如果是0就代表是正整数,如果首位是1则代表是负整数。

              先看首位是0的正整数,补齐位数以后,将二进制中的位数分别将下边对应的值相乘,然后相加得到的就为十进制,比如1010转换为十进制,方法如图7所示。

    8.  

      5、若二进制补足位数后首位为1时,就需要先取反再换算:例如,11101011,首位为1,那么就先取反吧:-00010100,然后算一下10100对应的十进制为20,所以对应的十进制为-20,方法如图8所示。

    9.  

      6、将有小数的二进制转换为十进制时:例如0.1101转换为十进制的方法:将二进制中的四位数分别于下边(如图9所示)对应的值相乘后相加得到的值即为换算后的十进制。

      END
    为什么要用反码和补码?
    先看正码表示,设N=4, -1 = 1001; -2 = 1010, -1 > -2, 但是 1001 < 1010,两种映射的编码的序性不一致
    反码呢,-1=1110, -2 = 1101,  Ok,序性正确了,
    然而,这里有一个问题,就是正数与负数之间,有一个1的缝隙。-1=1110, 1=0001,从循环编码的角度,这两个编码相差3:1110->1111->0000->0001。
    因为正零和负零是两个数,导致两个数系的断裂。怎么办?让负数整体往正数靠拢,迈进一步(+1),负1没有了。
    这就是求补的过程了。反码再加1。
     
    我想,当初写出计算机的编码设计论文的大牛(好像是图灵还是什么的),当然有更深的考虑。但从序性和数系联系的角度,补码的发明是相当合理的。而这种合理性,我个人认为,正是其优点。
     
    从机器实现的角度,并不算复杂,但相对反码的机器实现,还是多了+1的进位延时。

    转载于:https://www.cnblogs.com/crhdyl/p/4949387.html

    展开全文
  • 为什么二进制0代表正数,1代表负数

    千次阅读 2019-03-29 10:23:36
    https://blog.csdn.net/qq_41884002/article/details/81228998
  • 3.5.1 定点数浮点数的概念在计算机,数值型的数据有两种表示方法,一种叫做定点数,另一种叫做浮点数。所谓定点数,就是在计算机所有数的小数点位置固定不变。定点数有两种:定点小数定点整数。定点...
  • 文章目录面试题14:二进制中 1 的个数一、题目描述二、问题分析(1)思路一(2)思路二三、问题解决 面试题14:二进制中 1 的个数 一、题目描述 请实现一个函数,输入一个整数,输出该数二进制表示中1的个数。例如把...
  • n - 1会消除n的二进制位最后一个1(无论正负),所以消除的次数就代表二进制中1的个数。 循环会终结因为二进制中1的个数是有限的,而每次一定会消掉一个0 //C++ int NumberOf1(int n) { int cnt = ...
  • 文章目录前言求二进制中1的个数1、第一种思路:n & 11.对1左移左移代码2.把n右移右移代码右移缺陷2种改进代码2、第二种思路:n % 2代码3、第三种思路:n & (n-1) (最容易想不到的)代码 前言 求二进制中1的...
  • 二进制中1的个数 2,想法: (1),笨方法,把整数的二进制求出来,再遍历。 //递归输出二进制函数  void BinaryRecursion(int n)  {   int a;   a=n%2;   n=n〉〉1;   if (n==0)   ; ...
  • 题目链接地址: ...输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。 输入: 输入可能包含多个测试样例。 对于每个输入文件,第一行输入一个整数T,代表测试样例的数量。对于每个测
  • 二进制中负数的表示

    千次阅读 2017-03-18 18:11:31
    二进制里,是用 0 1 来表示正负的,最高位为符号位,最高位为 1 代表负数,最高位为 0 代表正数。   原码:一个整数,按照绝对值大小转换成的二进制数,称为原码。 比如 00000000 00000000 00000000 ...
  • 输入一个32位整数,输出该数二进制表示中1的个数。 注意: 负数在计算机中用其绝对值的补码来表示。 样例1 输入:9 ...解释:9的二进制表示是1001,一共有2个1。...解释:-2在计算机里会被...二进制是以0和1为码,逢...
  • Java 二进制

    2020-01-12 10:36:04
    二进制数据是用 0 1 两个数码来表示的数。 它的基数为 2,进位规则是 “逢二进一”,借位规则是 “借一当二” 1. 正整数的二进制表示法 十进制 二进制 十进制 二进制 十进制 二进制 十进制 二进制 0 0 ...
  • 用5除以2,取余的结果为1代表二进制表达含有一个1,此时的被除数变为5/2。循环直到被除数为0,循环结束。 注意:负数的二进制表示的首位为1.在计数之前需要判断n的正负。 代码: /** * 整数二进制中有多少
  • 输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。 分析: 首先,复习下java的int型表示范围: java的int型由4个字节组成,即32位。 减去最高位符号位,共有31位,故表示的范围是 正负2^32(10位...
  • 【剑指offer】二进制中1的个数

    千次阅读 2014-05-10 08:32:34
    输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。 输入: 输入可能包含多个测试样例。 对于每个输入文件,第一行输入一个整数T,代表测试样例的数量。对于每个测试样例输入为一个整数。 。n保证是...
  • java二进制

    2019-11-01 14:36:22
    java二进制 好久没有使用过二进制... 二进制: 由0和1两个数字组成。  八进制: 由0-7数字组成,为了区分与其他进制的数字区别,开头都是以0开始。  十进制: 都是以0-9这九个数字组成,不能以0开头。  十六进...
  • 输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。 题目分析 首先要明确,在计算机,负数是按照补码的形式存在的,所以该题不需要考虑正负的问题 本题采用二进制的方法,把当前数字转为二进制,...
  • 输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。 输入: 输入可能包含多个测试样例。 对于每个输入文件,第一行输入一个整数T,代表测试样例的数量。对于每个测试样例输入为一个整数。 。n...
  • 输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。 输入: 输入可能包含多个测试样例。 对于每个输入文件,第一行输入一个整数T,代表测试样例的数量。对于每个测试样例输入为一个整数。 。n...
  • 二进制里,是用 0 1 来表示正负的,最高位为符号位,最高位为 1 代表负数,最高位为 0 代表正数。以Java8位的byte为例,最大值为:0111 1111,最小值为1000 0001。那么根据十进制的数字,我们如何转换为...
  • 二进制中正负数表示判断

    千次阅读 2017-03-07 22:32:50
    二进制中第一位0代表正;1代表负我知道,但是给你一个二进制的数比如101 那么转化成十进制应该是多少?...如果你有这种疑问,那就是没有高清概念有问题,我们只有在说计算机处理数时,会用0和1代表正负,这种数
  • 二进制中原码补码与左移右移
  • 对于一个正整数如果是偶数,该数的二进制数的最后一位是 0 ,反之若是奇数,则该数的二进制数的最后一位是 1 。因此,可以考虑利用位移、判断奇偶来实现。 Java代码  public int bitCount(int x){ int...
  • Java二进制

    2019-07-24 18:42:08
    1. 什么是二进制 1.1 10进制 规律:逢10进1 数字:0 1 2 3 4 5 6 7 8 9 权(weight):个 十 百 千 万 基数(base):10 1.2 2进制 规律:逢2进1 数字:0 1 权(weight):32 16 8 4 2 1 基数(base):...
  • 算是读书笔记吧二进制编码二进制和我们平时用的十进制,其实并没有什么本质区别,只是平时我们是“逢十进一”,这里变成了“逢二... 0×2³+0×2²+1×2¹+1×2⁰ = 3十进制转二进制用2做短除法因此13这个十进制数,...
  • 一、二进制概念基于计算机内部组成原理,在内存字节是可寻址的最小单位,每个1字节由8个01二进制位组成(有时二进制位也称为比特,英文bit),最左边的二进制位称为最高位,最右边的二进制位称为最低位。...
  • 二进制里,是用0和1来表示正负的,最高位为符号位,最高位为1代表负数,最高位为0代表正数。 对于负数而言,是以补码的形式存储在内存的。以-8(int)为例, 第一步:将-8的绝对值转化为二进制 0000 1000 第二步...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,618
精华内容 5,047
关键字:

二进制中0和1代表正负