高精度加减乘除算法详解：从手写竖式到BigDecimal实战

有一次我在给学生讲大数加法，讲到一半突然意识到一个问题：我们天天用的int、long、double，其实从来没有告诉你“数字装不下了怎么办”。你写个2^100试试，long long直接给你一个莫名其妙的负数；你在Java里跑一句0.1+0.2，得出的也不是0.3而是0.30000000000000004。这些现象背后指向同一个话题——高精度加减乘除算法。

这篇文章我想把这块内容讲透。不管是算法竞赛里那些动辄几百位的大整数运算，还是业务系统里用BigDecimal做金额计算，或者是Python里处理输入输出时的精度陷阱，本质上都在跟“机器原生数字类型精度不够”这件事较劲。我会从底层原理讲起，把加减乘除四种运算的手写实现、工程实践、常见坑一次性说清楚，适合刚接触高精度算法的学生，也适合被金额计算精度问题折磨过的开发人员。

1. 高精度加减乘除，到底在解决什么问题

1.1 原生数字类型的精度边界

先看一组硬数据，这是所有编程语言共通的底层限制。

32位int能表示的最大整数是2147483647，也就是2^31-1；64位long long最大是9223372036854775807，也就是2^63-1。看起来挺大，但天文数字、组合数、大数幂运算随便一算就爆了。比如计算2^100，结果是1267650600228229401496703205376，这个数一共有31位，long long根本存不下，溢出后结果会变成一个无意义的负数。

浮点数更麻烦。double虽然能表示很大范围的数量级，但它只有53位二进制有效数字，折算成十进制大概是15到16位有效数字。也就是说，超过16位的整数部分，double根本不能保证精确表示。而且浮点数在设计上就是“近似值”，0.1在二进制里是一个无限循环小数，所以0.1+0.2会出现0.30000000000000004这种结果。

这就是高精度算法的核心价值：用数组或字符串存储数字的每一位，把四则运算拆成“手工竖式”的逐位计算，从而支持任意长度的数字精确运算。代价是速度比原生运算慢得多，但换来了精度上的上限突破。

1.2 哪些场景里躲不开高精度计算

我在实际工作中遇到的高精度场景，基本可以归成四类。

算法竞赛最典型。程序设计竞赛里经常出现n=1000的斐波那契数列、大数阶乘、大数幂运算，这些题的输出动不动就是几百位数字，不用高精度算法根本没法通过。除了C++选手要手写高精度，其实Java选手可以用BigInteger，Python选手直接依赖原生大整数，但原理是一样的，理解底层实现才能写出高效代码。

金融系统是最接地气的场景。任何涉及金额的计算都不能用浮点数，否则会出现分币差错。业务系统里一般会用BigDecimal或者decimal类型，加减乘除的精度和舍入规则必须严格把控，否则对不上账。

数据处理场景也很多。比如一个文件里有多行超长数字，需要做累加或者求平均值，因为数值太大可能超出数据库数值类型的范围，就需要在程序里用高精度方式处理。

还有一类是底层实现，比如加密算法、大整数分解、科学计算里的超长小数，这些领域的核心库内部就是用高精度算法实现任意精度运算的，只不过对性能要求极高，通常会用压位甚至FFT加速。

1.3 高精度运算的通用思路

不管是加法、减法还是乘法、除法，底层套路完全一致：用字符串读入，每位转成整数存进数组，再模拟手工计算过程。

这里有一个非常重要的约定，我会在后面反复用到：数组下标从0开始存个位，下标1存十位，下标2存百位，也就是“低位在前”。这样设计的原因很简单，加法进位或乘法增加位数时，结果可能比原来更长，数字往高位扩展只需要在数组末尾追加元素，非常方便。

理解了存储方式，剩下的事情就是用代码复刻你在小学二年级学过的竖式。

2. 高精度加法和减法：竖式思想的代码化

2.1 字符串到数组：先解决存储顺序

先写一个固定套路。读入一个大数，通常是字符串，然后转换成倒序的int数组。

以Python为例，最直观的转换方式是：

python复制s = input().strip()
a = [int(ch) for ch in s[::-1]]

C++也类似：

cpp复制string s;
cin >> s;
vector<int> a(s.size());
for (int i = 0; i < a.size(); i++) {
    a[i] = s[a.size() - 1 - i] - '0';
}

这里需要注意一个细节：读入的字符串如果前面有前导零，比如输入“000123”，转换后数组里就会有连续几个零。虽然在运算结果上没有问题，但会影响长度判断。我一般会在读入后先做一次清洗，去掉前导零，后面会少很多麻烦。

2.2 高精度加法实现与进位处理

两个大数相加，核心逻辑就是逐位相加并处理进位。模拟一下竖式：从个位开始，对应位相加，加上上一位的进位，如果结果大于等于10，就保留个位数并产生进位1。

C++实现大致是这样：

cpp复制vector<int> add(vector<int>& a, vector<int>& b) {
    vector<int> c;
    int carry = 0;
    int len = max(a.size(), b.size());
    for (int i = 0; i < len; i++) {
        int sum = carry;
        if (i < a.size()) sum += a[i];
        if (i < b.size()) sum += b[i];
        c.push_back(sum % 10);
        carry = sum / 10;
    }
    if (carry) c.push_back(carry);
    return c;
}

两个容易忽略的点值得专门说。

第一，短的数字高位视为0，所以循环长度取两者最大值，然后在循环内部判断下标是否越界。千万不要只遍历短的数组长度，否则高位直接丢失。

第二，循环结束后必须单独检查一次carry。比如999加1，按位算完，最后还有一个进位1，如果不单独处理，结果就会少一位。

这两条我见过无数人在比赛里翻车，属于高精度加法的经典坑。

2.3 高精度减法实现与借位处理

减法比加法多两个步骤：先比较大小确定正负号，再处理借位，最后去掉前导零。

先看大小比较。如果a的长度不等于b的长度，长的大；如果长度相等，从最高位（数组末尾）往低位逐位比较，找到第一个不相等的位，数值大者整个数更大。这里必须注意数组是倒序存的，所以最高位是数组末尾。

比较函数实现：

cpp复制// 返回 true 表示 a >= b
bool ge(vector<int>& a, vector<int>& b) {
    if (a.size() != b.size()) return a.size() > b.size();
    for (int i = a.size() - 1; i >= 0; i--) {
        if (a[i] != b[i]) return a[i] > b[i];
    }
    return true;
}

减法本身依旧模拟竖式：

cpp复制vector<int> sub(vector<int>& a, vector<int>& b) {
    vector<int> c;
    int borrow = 0;
    for (int i = 0; i < a.size(); i++) {
        int diff = a[i] - borrow;
        if (i < b.size()) diff -= b[i];
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        c.push_back(diff);
    }
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

这里的borrow就是借位：当前位不够减时，向高位借1当10，然后标记borrow为1，下一位计算时要先减掉这个借位。

去前导零这一步特别容易漏。比如100减99，按竖式算完得到001，如果不把前面的0清掉，输出就会变成001。while循环里c.size()>1这个条件也要留个心眼，至少要保留一位数字，如果结果是0，数组里应该有一个0，而不是空数组。

还有一个细节：调用sub之前先比较大小，如果a小于b，就把两个数对调再相减，结果加负号。符号处理一定要在调用前做，不要在sub函数内部处理，否则容易搞乱逻辑。

3. 高精度乘法：两层循环模拟手算竖式

3.1 朴素竖式乘法的实现思路

乘法比加减法复杂一个量级，但原理仍然很朴素。回想一下手算乘法是怎么做的：第一个数的每一位，依次乘以第二个数的每一位，然后把所有中间结果按位置累加，最后统一处理进位。

这里的关键是确认中间结果的位置关系。如果第一个数的第i位乘第二个数的第j位，它们的乘积应该放在结果的第i+j位上。比如个位乘个位，i=0, j=0，结果放在第0位；十位乘个位，结果放在第1位；十位乘十位，结果放在第2位。

基于这个规律，朴素乘法实现：

cpp复制vector<int> multiply(vector<int>& a, vector<int>& b) {
    vector<int> c(a.size() + b.size() + 1, 0);
    for (int i = 0; i < a.size(); i++) {
        for (int j = 0; j < b.size(); j++) {
            c[i + j] += a[i] * b[j];
        }
    }
    // 统一处理进位
    int carry = 0;
    for (int i = 0; i < c.size(); i++) {
        int val = c[i] + carry;
        c[i] = val % 10;
        carry = val / 10;
    }
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

这个写法的时间复杂度是O(n*m)，n和m分别是两个数的位数。它有个很优雅的思路：先把所有位的乘积累加在正确的位置上，不急着处理进位，最后用一次循环统一进位。这样做比“每位乘完立刻进位”要清晰得多，也更快。

结果数组长度为什么取a.size()+b.size()+1？因为两个n位数和m位数相乘，结果最多有n+m位，比如99乘99的结果是9801，正好4位。多预留一位是为了防止进位溢出，最后再通过pop_back去前导零收缩。

3.2 压位优化：让速度提升一个量级

朴素乘法虽然能工作，但效率比较低。如果数字有几千位甚至上万位，O(n*m)的代价会非常惊人。这时候有一个性价比极高的优化：压位。

思路很简单：数组里每个元素不再只存0到9，而是存一个更大的值域。比如用万进制，每个元素存0到9999，那么数组长度就缩短为原来的四分之一，乘法循环次数直接降到十六分之一，性能提升非常明显。

具体实现时，还是用同样的竖式逻辑，但进位条件从“大于等于10”变成“大于等于10000”，输出时需要补零：

cpp复制vector<int> multiply_base10000(vector<int>& a, vector<int>& b) {
    vector<int> c(a.size() + b.size() + 1, 0);
    for (int i = 0; i < a.size(); i++) {
        for (int j = 0; j < b.size(); j++) {
            c[i + j] += a[i] * b[j];
        }
    }
    int carry = 0;
    for (int i = 0; i < c.size(); i++) {
        long long val = c[i] + carry;
        c[i] = val % 10000;
        carry = val / 10000;
    }
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

这里有个坑必须提醒：如果数字长度翻倍，中间结果可能超过int范围。比如万进制下，两个9000相乘是81000000，数组里累加多个这样的数之后，int还能基本承受，但如果你的压位基数更大，比如亿进制，中间溢出风险极高，建议用long long存储累加结果。

压位的输出格式也有讲究。从高位往低位输出时，除了最高位之外，其余每个元素必须补足“基数长度”的0。比如万进制下，元素值是12，要输出成0012，否则数字会整体缩小或错位。

3.3 再往深走：Karatsuba与FFT

如果数字大到几十万位，O(n*m)的朴素乘法仍然不够快，需要更高级的算法。

Karatsuba算法是分治思想的应用。对于两个n位数，把它拆成高位和低位：a = a1B^k + a0, b = b1B^k + b0，那么a*b可以通过三次乘法而不是四次乘法算出，递推式T(n)=3T(n/2)+O(n)，时间复杂度降为O(n^1.585)。实现起来不算特别难，是很多高精度库的默认优化手段。

再往上就是FFT（快速傅里叶变换），把卷积转化成点值运算，时间复杂度O(n log n)，适用于百万位级别的超大数乘法。普通工程实践基本用不到，但如果你想深入底层原理，这是必经之路。

4. 高精度除法：最容易被细节坑的一块

4.1 高精度除以低精度：逐位试商

高精度除以一个普通的int，实现起来相对简单。做法是从最高位开始逐位处理：当前余数乘以10，加上当前位的数字，得到一个被除数片段，除以除数得到当前位的商，余数留下来继续用。

用C++描述：

cpp复制// 除数是int，假设除数不为0
vector<int> div_small(vector<int>& a, int divisor, int& remainder) {
    vector<int> c(a.size());
    long long cur = 0;
    for (int i = a.size() - 1; i >= 0; i--) {
        cur = cur * 10 + a[i];
        c[i] = cur / divisor;
        cur %= divisor;
    }
    // 去前导零
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    remainder = cur;
    return c;
}

注意这里遍历数组是从最高位（数组末尾）开始的，因为除法的竖式运算顺序是从高位到低位，跟加减乘法刚好相反。这也解释了为什么数组低位在前存储反而方便：要扩展高位时直接push_back，而除法要去掉商的前导零时也直接pop_back。

如果你需要保留小数点后的位，可以继续模拟。比如要算a/b保留k位小数，先用上述逻辑算出整数部分，得到一个余数，然后循环k次：每次余数乘10再除以除数，得到下一位小数，更新余数。这个过程同样要小心，余数为0时其实可以提前终止，避免白白循环。

4.2 高精度除以高精度：减法模拟与倍增试商

高精度除以高精度是四则运算里最麻烦的，核心难点在于每一位商怎么确定。

最直接的做法是用减法模拟：循环用被除数减去除数，每减一次商加一。但这种方法效率低到没法忍，如果被除数是1000000，除数是1，就要减一百万年。

换一个思路，仿照手算除法。从被除数的最高位开始，逐位把数字取下来，形成一个“当前剩余数”，这个数不断变大，直到它不小于除数，然后尝试找出一个最大的商q，使得q除数不超过当前剩余数。这个q就是当前位的商，当前剩余数减去q除数，得到新的余数，继续取下一个数字。

问题变成了：如何快速确定q。由于q只能是0到9（十进制一位一位试商），一个朴素做法是暴力尝试1到9，判断哪个最大且不越界。但在压位进制下，q可能很大，暴力查找会拖慢速度。

更好的办法是二分查找。对q的取值范围做二分，检查mid除数是否不超过当前剩余数。因为乘法本身是O(n)的，再加一层二分，总复杂度大约是O(nm*logn)，n是位数，m是除数位数。

我在工程里更推荐一个技巧：倍增试商。先估算q的大致范围，然后把这个范围乘2不断逼近，找到上界再回溯。这种方式避免了对整个取值范围做二分，常数更小。

不过说句实话，日常开发中真正需要“手写高精度除以高精度”的场景极少。绝大多数时候，用语言自带的高精度库就够了，真正手写一般是在算法竞赛或做底层库的时候。所以我把重点放在思路理解上，具体代码实现不必死记，关键是要知道它比除法低精度复杂在哪里。

5. Java里的BigDecimal：业务系统高精度加减乘除实战

5.1 BigDecimal构造陷阱：为什么不能直接new BigDecimal(0.1)

高精度算法手写是一回事，工程里用现成库是另一回事。Java生态里最常用的就是BigDecimal，但它在构造阶段就藏着一个经典的坑。

先看这段代码：

java复制BigDecimal a = new BigDecimal(0.1);
BigDecimal b = new BigDecimal(0.2);
System.out.println(a.add(b));

你猜输出多少？不是0.3，而是0.3000000000000000166533453693773481063544750213623046875。

原因在于new BigDecimal(double)用的是double的二进制近似值，而这个二进制近似值本身就不是精确的0.1。所以你从构造这一刻起，精度就已经被污染了。

正确的做法有两个。

第一是new BigDecimal("0.1")，用字符串构造。这样BigDecimal会严格解析字符串的每一位，得到精确的十进制数。

第二是BigDecimal.valueOf(0.1)，这个方法内部先调用了Double.toString，再走字符串构造，所以结果也是精确的。

我在项目里定的规矩很简单：凡是金额、税率这类关键数值，一律用字符串构造或者valueOf，禁止用new BigDecimal(double)。这是整个BigDecimal使用中最重要的一条铁律。

5.2 add、subtract、multiply的基础用法与结果不变性

BigDecimal的加减乘方法用起来很直接：

java复制BigDecimal a = new BigDecimal("10.55");
BigDecimal b = new BigDecimal("2.2");

BigDecimal sum = a.add(b);          // 12.75
BigDecimal diff = a.subtract(b);    // 8.35
BigDecimal prod = a.multiply(b);    // 23.210

这里有个容易被忽略的点：BigDecimal是不可变对象。add、subtract、multiply这些方法返回的是新对象，原来的a和b并不会被修改。很多人写代码时漏掉赋值，比如单独写一行a.add(b)，然后发现a的值没变，以为算错了。

对于加法减法乘法，只要两个操作数的scale（小数位数）合理，结果精度一般是自动判断的。add和subtract结果的小数位数取两个操作数中较大的scale；multiply结果的小数位数是两个操作数scale之和。比如10.55乘2.2，结果应该是23.210，末尾这个0会保留，因为scale=4。

5.3 divide方法的舍入模式：从Exception说起

BigDecimal里最坑的方法绝对是divide。如果你直接写：

java复制BigDecimal one = new BigDecimal("1");
BigDecimal three = new BigDecimal("3");
System.out.println(one.divide(three));

运行时会直接抛出ArithmeticException，提示Non-terminating decimal expansion。1除以3是无限循环小数，如果不指定精度，BigDecimal没法返回一个精确值，干脆就报错。

解决办法是手动指定小数点后保留几位和舍入模式：

java复制BigDecimal one = new BigDecimal("1");
BigDecimal three = new BigDecimal("3");
BigDecimal result = one.divide(three, 4, RoundingMode.HALF_UP);

这样算出来是0.3333。这里的RoundingMode.HALF_UP就是四舍五入，业务系统里最常用。

其他常用的舍入模式包括HALF_DOWN（五舍六入）、CEILING（向上取整）、FLOOR（向下取整）。金融计算中选哪种模式要谨慎，不同模式之间结果可能差一分钱。

工程上还有一个细节：做金额除以数量的场景，一般先计算精确值，再结合业务规则决定保留几位和舍入模式。比如订单金额分摊到多个商品，单价=总额/数量，一定不能直接拿原始值去divide，否则不同商品的分摊金额加起来可能不等于总额，需要用一个“最后一项兜底”的模式。

5.4 compareTo与equals的区别：金额比较的细节

比较两个BigDecimal是否相等，很多人会下意识用equals：

java复制new BigDecimal("1.0").equals(new BigDecimal("1.00"))

这个结果返回false。因为equals会比较scale，1.0的scale是1，1.00的scale是2，它们被认为是不同对象。

但数值上它们明明相等。所以在金额比较时，千万不能用equals，要用compareTo：

java复制new BigDecimal("1.0").compareTo(new BigDecimal("1.00")) == 0  // true

这个坑我在Code Review里见过很多次，一旦出现在金额判断逻辑里，很容易引发线上问题。

5.5 setScale的正确使用姿势

当我们需要把计算结果四舍五入到指定小数位时，会用到setScale。比如把23.210保留两位小数：

java复制BigDecimal prod = new BigDecimal("10.55").multiply(new BigDecimal("2.2"));
BigDecimal rounded = prod.setScale(2, RoundingMode.HALF_UP);

结果就是23.21。

setScale有两种使用场景：一种是从更多位小数缩到更少位，必须指定舍入模式；另一种是把0.1变成0.10这种补位操作，不需要舍入模式。但如果你对“不需要舍入”的情况也加了RoundingMode.UNNECESSARY，一旦实际计算中出现需要舍入的情况，就会抛异常，这其实是一种很好的防御性写法，可以帮你在测试阶段就发现问题。

6. Python高精度：开箱即用的大整数与decimal

6.1 Python整数自带高精度：简洁但容易被坑的输入输出

终于说到Python了。Python的int类型天生就是任意精度整数，理论上可以表示任意大的整数，不会溢出。比如算2^1000，直接在交互环境里输入2**1000，Python会一口气输出一个302位的完整数字。

这看起来特别美好，似乎不需要高精度算法了。但在实际使用中，问题往往不是出在运算，而是出在输入输出。

拿“python输入输出加减乘除”这个热搜词来说，新手最容易踩的坑是：input()返回的是字符串，必须先转换成int才能做算术运算。如果不做转换，两个字符串做加法只会拼接，比如输入12和34，直接a+b得到“1234”。

如果真的只是处理整数的加减乘除，Python一行就能搞定：

python复制a, b = map(int, input().split())
print(a + b)
print(a - b)
print(a * b)
print(a // b)

这里有一个需要特别说明的坑：除法用/得到浮点数，超大整数相除时直接转浮点数会丢失精度。比如10**50除以3，用/会得到一个科学计数法表示的浮点数，精度完全不够。想要精确的整数除法，必须用//（整除）和%（取余）。

如果你想处理的是小数的高精度加法和乘法，Python原生float同样不够用，0.1+0.2的结果依然是0.30000000000000004，需要用到decimal模块，和Java的BigDecimal异曲同工。

6.2 decimal模块：精确小数运算的标准方案

Python的decimal模块用法和Java BigDecimal很像，核心是用Decimal构造精确数值：

python复制from decimal import Decimal, getcontext, ROUND_HALF_UP

a = Decimal("0.1")
b = Decimal("0.2")
print(a + b)  # 精确输出0.3

注意这里同样是用字符串构造Decimal，不能直接Decimal(0.1)，否则会把double的近似值传进去，结果照样不精确。

decimal模块有一个全局上下文getcontext()，里面定义了精度。默认的prec是28，意思是最多保留28位有效数字。如果你需要更多位，可以调整：

python复制getcontext().prec = 50

除法的处理也类似BigDecimal，需要指定精度和舍入模式。decimal的quantize方法可以按指定精度舍入：

python复制from decimal import Decimal, ROUND_HALF_UP
result = Decimal("1") / Decimal("3")
rounded = result.quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
print(rounded)  # 0.3333

还有一个容易被忽略的点：Decimal的加法乘法结果，位数的变化逻辑跟BigDecimal不完全一样，它遵循上下文prec的有效数字位数控制，而不是严格的小数位数控制。如果你要做固定小数位数的业务计算，最好在每一步都用quantize把结果规范到同一scale，避免位数越算越多。

6.3 Python高精度实战：大数阶乘和格式化输出

写一个综合的例子。计算1000的阶乘，并把结果完整打印出来：

python复制import math
number = math.factorial(1000)
s = str(number)
print(len(s))  # 输出位数
print(s)       # 输出完整数字

这种几百位的运算，在C++里要手写高精度乘法，在Python里一行就行。但如果你想打印成财务要求的格式，比如每三位加一个逗号，直接用format：

python复制print(f"{number:,}")

Python的格式化功能非常强大，高精度数字打印时完全不用自己处理字符串拼接。

如果要从文件里读入大量大整数并求和，直接按行读取后累加：

python复制total = 0
with open("numbers.txt") as f:
    for line in f:
        total += int(line.strip())
print(total)

这里的total初始是0，因为Python的int可以无限扩展，所以累加过程完全不用担心溢出。用C++写同样功能，估计要先把所有读入的数字存下来然后做高精度加法，这就是Python最舒服的地方。

7. 常见问题排查与实操心得

7.1 高精度代码里反复出现的五个坑

写高精度代码这几年，我总结出一个高频翻车清单，每个问题都对应一个具体场景。

第一个是数组越界。乘法里结果数组的长度估计不对，或者加法循环时忘记判断下标是否越界。我见过的最典型错误是：一个三位数乘一个三位数，结果预留长度只有5位，但实际结果可能是6位，导致最后一位进位无处安放。

第二个是进位忘记收尾。加法算完最有一位后还有进位没处理，或者乘法统一进位时循环范围少算了最后一位。这个问题在测试用例全9相加时最容易被发现。

第三个是前导零未去除。减法和除法尤其容易出问题。100减99得到001，如果不清理就是错的；除法如果被除数比除数小，商可能变成0开头的一串数字，需要处理成单个0。

第四个是负数处理考虑不全。减法比较大小后，如果结果是负数但没有加负号，或者比较函数写错导致a-b和b-a的结果一样。我的建议是写一个单独的sign判断，不要混在sub函数里。

第五个是字符串转换时的字符偏移错误。字符'0'的ASCII码是48，转整数要减'0'，不是减0。这种错误在C/C++里特别常见，肉眼还看不出问题，输出结果要么偏大要么偏小。

我把这些坑整理成一个速查表，方便大家统一排查：

7.2 我写高精度代码的习惯

最后分享几个个人习惯，不一定是最优解，但是能有效减少bug。

先把输入的数字做成统一格式再运算。我习惯写一个normalize函数，把字符串的前导零清掉，同时保证空串或空值处理成“0”。这样后续所有逻辑都不用担心脏数据。

写高精度运算前先写测试用例，把各种边界条件列出来：0加0、99加1、100减99、1乘1、999乘999、1除以3保留小数，这些用例覆盖了99%的常见坑。先跑一遍再投入正式使用，能省下大量debug时间。

出错时优先打印数组而不是打印最终字符串。因为高精度结果转换为字符串时，前导零、补零逻辑本身也可能有bug，打印数组可以直接看到每一位的原始值，定位问题快很多。

还有一点是关于BigDecimal和decimal的使用。我建议所有涉及金额的项目，哪怕是读取数据库里的数值，最好统一用字符串或者BigDecimal.valueOf传入。数据库返回的金额如果本身是BigDecimal类型就没问题，但如果你拿到的是double，先转成字符串再构造，避免精度污染。

7.3 性能优化和高精度库的选择

如果项目里只是单纯需要高精度整数运算，不建议从头手写一套完整的四则运算。Java直接用BigInteger，Python直接用int，C++可以用Boost.Multiprecision里的cpp_int，这些都是经过大量测试的开源实现，比你自己写的健壮得多。

手写高精度算法的价值主要在于学习原理、算法竞赛和特殊场景定制。比如你要在嵌入式设备上实现一个极简的大数计算器，内存和CPU都有限，这时候根据需求定制一个压位版本更合适。

如果你真的要在竞赛里手写高精度，我建议至少掌握到压位级别。压位能让乘法性能提升一到两个数量级，代码复杂度只增加一点点，性价比极高。再往上的Karatsuba和FFT，根据题目需要再学，不必一上来就死磕。

7.4 个人经验：一次金融系统的精度事故复盘

最后讲一个真实案例收尾。

之前做过一个财务对账系统，某个模块把数据库里的金额字段取出后，直接用double做了一次乘法再塞回报表。表面看金额是两位小数，double在十几万以内似乎不会出错。但一旦金额超过千万，double的53位有效数字开始不够用，计算小数后面那几位竟然出现了偏差。数据量大了之后，有两笔订单的对账差异正好差了一分钱。

排查过程很费劲，因为普通打印看不出问题，后来我用BigDecimal重新算了一遍，发现是浮点数乘法过程里的微小误差被金额取整规则放大了。那次之后，我给自己定了三条规矩：金额计算一律用BigDecimal，禁止double；所有金额比较用compareTo，不用equals；除法必须先定scale和舍入模式再执行。

这三条规矩后来在多个项目里帮我避开了不少雷，也值得大家直接抄作业。高精度加减乘除算法看起来是个很基础的话题，但它在不同场景下的变形非常多，理解了原理，再配合语言自带库的正确用法，才能在业务里真正不出错。