三、数据背后的二进制

文章目录

数据背后的二进制
- [1.1 整数的二进制表示与位运算](#1.1 整数的二进制表示与位运算)
- - [1.1.1 正整数的二进制表示](#1.1.1 正整数的二进制表示)
  - [1.1.2 负整数的二进制表示](#1.1.2 负整数的二进制表示)
- [1.2 原码、反码、补码](#1.2 原码、反码、补码)
- - [1.2.1 机器数和机器数的真值](#1.2.1 机器数和机器数的真值)
  - [1.2.2 原码, 反码, 补码的基础概念和计算方法](#1.2.2 原码, 反码, 补码的基础概念和计算方法)
  - [1.2.3 为何要使用原码、反码和补码](#1.2.3 为何要使用原码、反码和补码)
  - [1.2.4 补码计算原理](#1.2.4 补码计算原理)
- [1.3 小数的二进制表示](#1.3 小数的二进制表示)
- - [2.3.1 小数为什么会出错](#2.3.1 小数为什么会出错)
  - [2.3.2 二进制表示](#2.3.2 二进制表示)
- [1.4 字符的编码和乱码](#1.4 字符的编码和乱码)
- - [1.4.1 常见非`Unicode`编码](#1.4.1 常见非Unicode编码)
  - [1.4.2 Unicode编码](#1.4.2 Unicode编码)
  - [1.4.3 编码转换](#1.4.3 编码转换)
  - [1.4.4 乱码原因](#1.4.4 乱码原因)
  - [1.4.5 从乱码中恢复](#1.4.5 从乱码中恢复)
- [1.5 Java 中的char](#1.5 Java 中的char)

数据背后的二进制

本文为书籍《Java编程的逻辑》^[1](#1)和《剑指Java：核心原理与应用实践》^[2](#2)阅读笔记

java 复制代码

public void TestMy() {
    int a = 2147483647 * 2;
    System.out.println(a); // 正整数相乘的结果居然出现了负数
    System.out.println(0.1 * 0.1); // 非常基本的小数运算结果居然不精确。
    char c = 'A';
    System.out.println((c + 32)); // 字符类型也可以进行算术运算和比较。
    System.out.println((char) (c + 32)); // 字符类型和整型可以相互转换。
}

上述代码运算得到：

复制代码

-2
0.010000000000000002
97
a

上面体现了四个问题：

正整数相乘的结果居然出现了负数：整型 a ∗ 2 a*2 a∗2得到了 − 2 -2 −2；
0.1 ∗ 0.1 0.1*0.1 0.1∗0.1得不到 0.01 0.01 0.01，而是 0.010000000000000002 0.010000000000000002 0.010000000000000002；
c h a r char char类型数据可以和整型数据运算；
c h a r char char类型数据可以和整数相互转换；

要理解上述的行为，就需要理解计算机是如何保存数据，这部分分为三部分，一部分介绍整数，一部分介绍小数，最后一部分介绍字符的基本类型 c h a r char char以及文本的编码。

1.1 整数的二进制表示与位运算

要理解整数的二进制，我们先来看下熟悉的十进制整数。比如 123 123 123，可以表示为： 1 × ( 1 0 2 ) + 2 × ( 1 0 1 ) + 3 × ( 1 0 0 ) 1×(10^2)+2× (10^1)+3× (10^0) 1×(102)+2×(101)+3×(100)，它表示的是各个位置数字含义之和，每个位置的数字含义与位置有关，从右向左，数字含义为第一位数字乘以 1 0 0 = 1 10^0=1 100=1，第二位数字乘以 1 0 1 = 10 10^1=10 101=10，即 10 10 10，第三位数字乘以 1 0 2 = 100 10^2=100 102=100，以此类推。换句话说，每个位置都有一个位权，从右到左，第一位为 1 1 1，然后依次乘以 10 10 10，即第二位为 10 10 10，第三位为 100 100 100，以此类推。

1.1.1 正整数的二进制表示

正整数的二进制表示与此类似，只是在十进制中，每个位置可以有 10 10 10个数字，为 0 ∼ 9 0\sim9 0∼9，但在二进制中，每个位置只能是 0 0 0或 1 1 1。位权的概念是类似的，从右到左，第一位为 1 1 1，然后依次乘以 2 2 2，即第二位为 2 2 2，第三位为 4 4 4，以此类推。

java中Integer.toBinaryString可以获得整数的二进制表示。如下面代码，调用Integer.toBinaryString函数，获取几个正整数的二进制表示如下：

java 复制代码

    @Test
    public void testPositiveIntegerBinaryRepresentation() {
        assertTrue("01111111111111111111111111111111"
                .equals(StringUtils.leftPad(Integer.toBinaryString(2_147_483_647), 32, "0")));
        assertTrue("00000000000000000000000000000000"
                .equals(StringUtils.leftPad(Integer.toBinaryString(0), 32, "0")));
        assertTrue("00000000000000000000000000000010"
                .equals(StringUtils.leftPad(Integer.toBinaryString(2), 32, "0")));
        assertTrue("00000000000000000000000000000011"
                .equals(StringUtils.leftPad(Integer.toBinaryString(3), 32, "0")));
        assertTrue("00000000000000000000000000001010"
                .equals(StringUtils.leftPad(Integer.toBinaryString(10), 32, "0")));
    }

1.1.2 负整数的二进制表示

十进制的负数表示就是在前面加一个负数符号 − - −即可，例如 − 123 -123 −123。但二进制如何表示负数呢？其实概念是类似的，二进制使用最高位表示符号位，用 1 1 1表示负数，用 0 0 0表示正数。但哪个是最高位呢？整数有 4 4 4种类型byte、short、int、long，分别占1、2、4、8个字节，即分别占8、16、32、64位，每种类型的符号位都是其最左边的一位。为方便举例，下面假定类型是byte，即从右到左的第8位表示符号位。对比十进制负整数，负整数的二进制是不是简单地将最高位变为 1 1 1即可呢？下面看几个负数二进制表示的例子。

(byte) -1，如果只是将最高位变为 1 1 1，二进制应该是 1000 0001 1000\ 0001 1000 0001，但实际上，它应该是 1111 1111 1111\ 1111 1111 1111。
(byte) -127，如果只是将最高位变为 1 1 1，二进制应该是 1111 1111 1111\ 1111 1111 1111，但实际上，它却应该是 1000 0001 1000\ 0001 1000 0001。

java 复制代码

	@Test
	public void testNegativeIntegerBinaryRepresentation() {
		assertTrue("00000001".equals(Integer.toBinaryString(((byte) 1 & 0xFF) + 0x100).substring(1)));
		assertTrue("11111111".equals(Integer.toBinaryString(((byte) -1 & 0xFF) + 0x100).substring(1)));
		assertTrue("10000001".equals(Integer.toBinaryString(((byte) -127 & 0xFF) + 0x100).substring(1)));
	}

为什么跟我们的直觉相反呢？因为计算机中使用补码保存数据，那么什么是补码，补码如何计算以及为什么计算机使用补码保存数据呢？

1.2 原码、反码、补码

本文参考博客《原码、反码、补码》^[3](#3)

1.2.1 机器数和机器数的真值

在学习原码，反码和补码之前，需要先了解机器数 和真值的概念。

1、机器数

一个数在计算机中的二进制表示形式，叫做这个数的机器数。机器数是带符号的，在计算机用机器数的最高位 存放符号，正数为 0 0 0，负数为 1 1 1。比如，十进制中的数 + 3 +3 +3，计算机字长为8位 ，转换成二进制就是 0000 0011 0000\ 0011 0000 0011。如果是 − 3 -3 −3，就是 100 00011 100\ 00011 100 00011。那么，这里的 0000 0011 0000\ 0011 0000 0011和 1000 0011 1000\ 0011 1000 0011就是机器数。

2、机器数的真值

因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 1000 0011 1000\ 0011 1000 0011，其最高位 1 1 1代表负，其真正数值是 − 3 -3 −3，而不是形式值 131 131 131（ 1000 0011 1000\ 0011 1000 0011转换成十进制等于 131 131 131）。所以，为区别起见，将带符号位的机器数对应的真正数值 称为机器数的真值 。例： 00000001 0000 0001 00000001的真值 = + 000 0001 = + 1 = +000\ 0001 = +1 =+000 0001=+1， 1000 0001 1000\ 0001 1000 0001的真值 = -- 000 0001 = -- 1 = --000\ 0001 = --1 =--000 0001=--1

1.2.2 原码, 反码, 补码的基础概念和计算方法

在探求为何机器要使用补码之前，让我们先了解原码、反码和补码的概念。对于一个数，计算机要使用一定的编码方式进行存储，原码、反码、补码是机器存储一个具体数字的编码方式。

1. 原码

原码就是符号位加上真值的绝对值 ，即用第一位表示符号，其余位表示值。比如：如果是 8 8 8位二进制：

1 +1 +1的原码= 0000 0001 0000\ 0001 0000 0001

− 1 -1 −1的原码 = 1000 0001 = 1000\ 0001 =1000 0001

第一位是符号位，因为第一位是符号位，所以8位二进制数的取值范围就是：（即第一位不表示值，只表示正负） [ 1111 1111 , 0111 1111 ] [1111\ 1111,\ 0111\ 1111] [1111 1111, 0111 1111]，即 [ − 127 , 127 ] [-127,\ 127] [−127, 127]。原码是人脑最容易理解和计算的表示方式。

2. 反码

反码的表示方法是：正数的反码是其本身；负数的反码是在其原码的基础上，符号位不变，其余各个位取反。

1 +1 +1 的原码 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]，反码 = [ 0000 0001 ] =[0000\ 0001] =[0000 0001]

− 1 -1 −1的原码 = [ 1000 0001 ] = [1000\ 0001] =[1000 0001]，反码 = [ 1111 1110 ] = [1111\ 1110] =[1111 1110]

可见如果一个反码表示的是负数，人脑无法直观的看出来它的数值。通常要将其转换成原码再计算。

3. 补码

补码的表示方法是：正数的补码就是其本身；负数的补码是在其原码的基础上，符号位不变，其余各位取反，最后 + 1 +1 +1（也即在反码的基础上 + 1 +1 +1）。

1 +1 +1的原码 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]，反码 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]，补码 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]

− 1 -1 −1的原码 = [ 1000 0001 ] = [1000\ 0001] =[1000 0001]，反码 = [ 1111 1110 ] = [1111\ 1110] =[1111 1110]，补码 = [ 1111 1111 ] = [1111\ 1111] =[1111 1111]

对于负数，补码表示方式也是人脑无法直观看出其数值的。通常也需要转换成原码再计算其数值。

1.2.3 为何要使用原码、反码和补码

现在我们知道了计算机可以有三种编码方式表示一个数，对于正数因为三种编码方式的结果都相同：

1 +1 +1的原码 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]，反码 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]，补码 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]

所以不需要过多解释，但是对于负数：

− 1 -1 −1的原码 = [ 1000 0001 ] = [1000\ 0001] =[1000 0001]，反码 = [ 1111 1110 ] = [1111\ 1110] =[1111 1110]，补码 = [ 1111 1111 ] = [1111\ 1111] =[1111 1111]

可见原码，反码和补码是完全不同的。既然原码才是被人脑直接识别并用于计算表示方式，为何还会有反码和补码呢？首先, 因为人脑可以知道第一位是符号位，在计算的时候我们会根据符号位，选择对真值区域的加减。但是对于计算机，加减乘除已经是最基础的运算，要设计的尽量简单，计算机辨别"符号位"显然会让计算机的基础电路设计变得十分复杂！于是人们想出了将符号位也参与运算的方法。我们知道，根据运算法则减去一个正数等于加上一个负数，即： 1 − 1 = 1 + ( − 1 ) = 0 1-1 = 1 + (-1) = 0 1−1=1+(−1)=0，所以机器可以只有加法而没有减法，这样计算机运算的设计就更简单了。于是人们开始探索将符号位参与运算，并且只保留加法的方法。首先来看原码：

计算十进制的表达式： 1 − 1 = 0 1 - 1 = 0 1−1=0

1 − 1 = 1 + ( − 1 ) = [ 0000 0001 ] 1 - 1 = 1 + (-1) = [0000\ 0001] 1−1=1+(−1)=[0000 0001]原 + [ 1000 0001 ] + [1000\ 0001] +[1000 0001]原 = [ 1000 0010 ] = [1000\ 0010] =[1000 0010]原 = − 2 = -2 =−2

如果用原码表示，让符号位也参与计算，显然对于减法来说，结果是不正确的。这也就是为何计算机内部不使用原码表示一个数。

为了解决原码做减法的问题，出现了反码：

计算十进制的表达式： 1 − 1 = 0 1 - 1 = 0 1−1=0

1 − 1 = 1 + ( − 1 ) = [ 0000 0001 ] 1 - 1 = 1 + (-1) = [0000\ 0001] 1−1=1+(−1)=[0000 0001]原 + [ 1000 0001 ] + [1000\ 0001] +[1000 0001]原 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]反 + [ 1111 1110 ] + [1111\ 1110] +[1111 1110]反 = [ 1111 1111 ] = [1111\ 1111] =[1111 1111]反 = [ 1000 0000 ] = [1000\ 0000] =[1000 0000]原 = − 0 = -0 =−0

发现用反码计算减法，结果的真值部分是正确的。而唯一的问题其实就出现在"0"这个特殊的数值上，虽然人们理解上**+0和-0**是一样的，但是 0 0 0带符号是没有任何意义的，而且会有[0000 0000]原和[1000 0000]原两个编码表示 0 0 0。

于是补码的出现，解决了0的符号问题以及0的两个编码问题：

1 − 1 = 1 + ( − 1 ) = [ 0000 0001 ] 1-1 = 1 + (-1) = [0000\ 0001] 1−1=1+(−1)=[0000 0001]原 + [ 1000 0001 ] + [1000\ 0001] +[1000 0001]原 = [ 0000 0001 ] = [0000\ 0001] =[0000 0001]补 + [ 1111 1111 ] + [1111\ 1111] +[1111 1111]补 = [ 10000 0000 ] = [1 0000\ 0000] =[10000 0000]补 = [ 0000 0000 ] =[0000\ 0000] =[0000 0000]补 = [ 0000 0000 ] =[0000\ 0000] =[0000 0000]原

注意：进位 1 1 1不在计算机字长里。

这样0用[0000 0000]表示，而以前出现问题的-0则不存在了。而且可以用[1000 0000]表示-128：-128的由来如下：

( − 1 ) + ( − 127 ) = [ 1000 0001 ] (-1) + (-127) = [1000\ 0001] (−1)+(−127)=[1000 0001]原 + [ 1111 1111 ] + [1111\ 1111] +[1111 1111]原 = [ 1111 1111 ] = [1111\ 1111] =[1111 1111]补 + [ 1000 0001 ] + [1000\ 0001] +[1000 0001]补 = [ 1000 0000 ] = [1000\ 0000] =[1000 0000]补

− 1 − 127 -1-127 −1−127的结果应该是 − 128 -128 −128，在用补码运算的结果中，[1000 0000]补就是 − 128 -128 −128，但是注意因为实际上是使用以前的 − 0 -0 −0的补码来表示 − 128 -128 −128，所以 − 128 -128 −128并没有原码和反码表示。（对 − 128 -128 −128的补码表示[1000 0000]补，算出来的原码是[0000 0000]原，这是不正确的）。

使用补码，不仅仅修复了 0 0 0的符号以及存在两个编码的问题，而且还能够多表示一个最低数。这就是为什么 8 8 8位二进制，使用原码或反码表示的范围为 [ − 127 , + 127 ] [-127, +127] [−127,+127]，而使用补码表示的范围为 [ − 128 , 127 ] [-128, 127] [−128,127]。因为机器使用补码，所以对于编程中常用到的有符号的 32 32 32位 i n t int int类型，可以表示范围是： [ − 2 31 , 2 31 − 1 ] [-2^{31}, 2^{31}-1] [−231,231−1]。因为第一位表示的是符号位，而使用补码表示时又可以多保存一个最小值。

1.2.4 补码计算原理

计算机巧妙地把符号位参与运算，并且将减法变成了加法，背后蕴含了怎样的数学原理呢？将钟表想象成是一个 1 1 1位的 12 12 12进制数。如果当前时间是 6 6 6点，我希望将时间设置成 4 4 4点，需要怎么做呢？我们可以：

往回拨 2 2 2个小时： 6 − 2 = 4 6 - 2 = 4 6−2=4
往前拨 10 10 10个小时： ( 6 + 10 ) m o d 12 = 4 (6 + 10)\ mod\ 12 = 4 (6+10) mod 12=4
往前拨 10 + 12 = 22 10+12=22 10+12=22个小时： ( 6 + 22 ) m o d 12 = 4 (6+22)\ mod\ 12 =4 (6+22) mod 12=4

上面2、3方法中的mod是指取模操作， 16 m o d 12 = 4 16\ mod\ 12=4 16 mod 12=4，即用 16 16 16除以 12 12 12后的余数是 4 4 4。所以钟表往回拨（减法）的结果可以用往前拨（加法）替代！现在的焦点就落在了如何用一个正数，来替代一个负数呢？上面的例子我们能感觉出来一些端倪，发现一些规律。但是数学是严谨的，不能靠感觉。首先介绍一个数学中相关的概念：同余。同余的概念 ：两个整数 a a a， b b b，若它们除以整数 m m m所得的余数相等，则称 a a a， b b b对于模 m m m同余，记作 a ≡ b ( m o d m ) a \equiv b\ (\ mod\ m) a≡b ( mod m)，读作 a a a与 b b b关于模 m m m同余。

举例说明：

4 m o d 12 = 4 4\ mod\ 12\ =\ 4 4 mod 12 = 4
16 m o d 12 = 4 16\ mod\ 12\ =\ 4 16 mod 12 = 4
28 m o d 12 = 4 28\ mod\ 12\ =\ 4 28 mod 12 = 4

所以 4 4 4， 16 16 16， 28 28 28对于模 12 12 12同余。

负数取模

正数进行mod运算是很简单的，但是负数呢？下面是关于mod运算的数学定义：

x m o d y = x − y ⌊ x y ⌋ , f o r y ≠ 0 x\ mod\ y=\ x-y\lfloor {\frac{x}{y}} \rfloor,\qquad for\qquad y\neq0 x mod y= x−y⌊yx⌋,fory=0

上面公式的意思是:

x mod y 等于 x 减去 y 乘上 x 与 y 的商的下界。

举例如下：

− 3 m o d 2 = − 3 − 2 ⌊ − 3 2 ⌋ = − 3 − 2 × ⌊ − 1.5 ⌋ = − 3 − 2 × ( − 2 ) = − 3 + 4 = 1 -3\ mod\ 2=-3-2\lfloor\frac{-3}{2}\rfloor=-3-2\times\lfloor-1.5\rfloor=-3-2\times(-2)=-3+4=1 −3 mod 2=−3−2⌊2−3⌋=−3−2×⌊−1.5⌋=−3−2×(−2)=−3+4=1

− 2 m o d 12 = − 2 − 12 ⌊ − 2 12 ⌋ = − 2 − 12 × ( − 1 ) = 10 -2\ mod\ 12 =-2-12\lfloor\frac{-2}{12}\rfloor=-2-12\times(-1)=10 −2 mod 12=−2−12⌊12−2⌋=−2−12×(−1)=10

− 4 m o d 12 = − 4 − 12 ⌊ − 4 12 ⌋ = − 4 − 12 × ( − 1 ) = 8 　 -4\ mod\ 12=-4-12\lfloor\frac{-4}{12}\rfloor = -4-12\times(-1)=8　 −4 mod 12=−4−12⌊12−4⌋=−4−12×(−1)=8

− 5 m o d 12 = − 5 − 12 ⌊ − 5 12 ⌋ = − 5 − 12 × ( − 1 ) = 7 　 -5\ mod\ 12 = -5-12\lfloor\frac{-5}{12}\rfloor=-5-12\times(-1)=7　 −5 mod 12=−5−12⌊12−5⌋=−5−12×(−1)=7

开始证明

再回到时钟的问题上，根据前面介绍，我们知道：

回拨2小时 = 前拨10小时
回拨4小时 = 前拨8小时
回拨5小时= 前拨7小时

结合上面学到的同余的概念，实际上：

− 2 m o d 12 = 10 m o d 12 = 10 -2\ mod\ 12=10\ mod\ 12=10 −2 mod 12=10 mod 12=10， − 2 -2 −2与 10 10 10是同余的，

− 4 m o d 12 = 8 m o d 12 = 8 -4\ mod\ 12 =8\ mod\ 12 = 8 −4 mod 12=8 mod 12=8， − 4 -4 −4与 8 8 8是同余的。

距离成功越来越近了。要实现用正数替代负数，只需要运用同余数的两个定理：

反身性： a ≡ a ( m o d m ) a \equiv a\ (\ mod\ m) a≡a ( mod m)
线性运算定理 ：如果 a ≡ b ( m o d m ) a \equiv b\ (\ mod\ m) a≡b ( mod m)， c ≡ d ( m o d m ) c ≡ d\ (\ mod\ m) c≡d ( mod m)那么： a ± c ≡ b ± d ( m o d m ) a \pm c \equiv b \pm d\ (\ mod\ m) a±c≡b±d ( mod m) 以及 a × c ≡ b × d ( m o d m ) a \times c \equiv b \times d\ (\ mod\ m) a×c≡b×d ( mod m)

所以：

7 ≡ 7 ( m o d 12 ) 7\equiv7\ (\ mod\ 12) 7≡7 ( mod 12)

− 2 ≡ 10 ( m o d 12 ) -2\equiv10\ (\ mod\ 12) −2≡10 ( mod 12)

7 − 2 ≡ 7 + 10 ( m o d 12 ) 7-2 \equiv 7 + 10 (\ mod\ 12) 7−2≡7+10( mod 12)

5 ≡ 17 ( m o d 12 ) 5 \equiv 17 (\ mod\ 12) 5≡17( mod 12)

现在我们为一个负数，找到了它的正数同余数。但是并不是 7 − 2 = 7 + 10 7-2 = 7+10 7−2=7+10，而是 7 − 2 ≡ 7 + 10 ( m o d 12 ) 7-2 \equiv 7 + 10\ (\ mod\ 12) 7−2≡7+10 ( mod 12)，即计算结果的余数相等。

接下来回到二进制的问题上，看一下： 2 − 1 = 1 2-1=1 2−1=1的问题。

2 − 1 = 2 + ( − 1 ) = [ 0000 0010 ] 2-1=2+(-1) = [0000\ 0010] 2−1=2+(−1)=[0000 0010]原 + [ 1000 0001 ] + [1000\ 0001] +[1000 0001]原 = [ 0000 0010 ] = [0000\ 0010] =[0000 0010]反 + [ 1111 1110 ] + [1111\ 1110] +[1111 1110]反

先到这一步， − 1 -1 −1的反码表示是 1111 1110 1111\ 1110 1111 1110。如果这里将 [ 1111 1110 ] [1111\ 1110] [1111 1110]认为是原码，则 [ 1111 1110 ] [1111\ 1110] [1111 1110]原 = − 126 = -126 =−126，这里将符号位除去，即认为是 126 126 126。

发现有如下规律：

( − 1 ) m o d 127 = 126 (-1)\ mod\ 127\ =\ 126 (−1) mod 127 = 126

126 m o d 127 = 126 126\ mod\ 127 = 126 126 mod 127=126

即：

2 ≡ 2 ( m o d 127 ) 2 \equiv 2\ (\ mod\ 127) 2≡2 ( mod 127)

( − 1 ) ≡ 126 ( m o d 127 ) (-1) ≡ 126\ (\ mod\ 127) (−1)≡126 ( mod 127)

2 − 1 ≡ 2 + 126 ( m o d 127 ) 2-1 ≡ 2+126 (\ mod\ 127) 2−1≡2+126( mod 127)

2 − 1 2-1 2−1 与 2 + 126 2+126 2+126的余数结果是相同的！而这个余数，正式我们的期望的计算结果： 2 − 1 = 1 2-1=1 2−1=1

所以说一个数的反码，实际上是这个数对于一个模的同余数。而这个模并不是我们的二进制，而是所能表示的最大值！这就和钟表一样，转了一圈后总能找到在可表示范围内的一个正确的数值！而 2 + 126 2+126 2+126很显然相当于钟表转过了一轮，而因为符号位是参与计算的，正好和溢出的最高位形成正确的运算结果。

既然反码可以将减法变成加法，那么现在计算机使用的补码呢？为什么在反码的基础上加 1 1 1，还能得到正确的结果？

2 − 1 = 2 + ( − 1 ) = [ 00000010 ] 2-1=2+(-1) = [0000 0010] 2−1=2+(−1)=[00000010]原 + [ 10000001 ] + [1000 0001] +[10000001]原 = [ 00000010 ] = [0000 0010] =[00000010]补 + [ 11111111 ] + [1111 1111] +[11111111]补

如果把 [ 11111111 ] [1111 1111] [11111111]当成原码，去除符号位，则：