我认为程序员应该已经实现了自己的bignum库，因此欢迎在这里。
（当然，稍后你会发现BigInteger更好，并且可以使用它，但这是宝贵的学习经验。）
（你可以在github上关注本课程的源代码。此外，我将此内容（略有修饰）重新制作成了一个由14部分组成的博客系列。）
用Java创建一个简单的Big number类
那么，我们需要什么呢？
首先，用数字表示
基于Java给我们的数据类型。
你认为十进制转换是最复杂的部分，让我们停留在基于十进制的模式下。为了提高效率，我们将不存储真实的十进制数字，而是使用
base 1 000 000 000 = 10^9 < 2^30。这适合于Java
int（最大为
2^31或
2^32），而两个这样的数字的乘积恰好适合于Java long。
final static int base = 1000000000;final static int base_DECIMAL_DIGITS = 9;
然后是数字数组：
private int[] digits;
我们是否将数字存储在小端或大端中，即较大的部分在前还是后？这并不重要，因此我们决定选择大端字节，因为这是人类想要阅读的方式。（目前，我们专注于非负值-稍后我们将为负数添加一个符号位。）
为了进行测试，我们添加了一个构造函数，该构造函数允许从此类int []进行初始化。
public DecimalBigInt(int... digits) { for(int digit : digits) { if(digit < 0 || base <= digit) { throw new IllegalArgumentException("digit " + digit + " out of range!"); } } this.digits = digits.clone();}此外，此构造函数还可用于单个int（如果小于base），甚至不可用int（我们将其解释为0）。因此，我们现在可以执行以下操作：
DecimalBigInt d = new DecimalBigInt(7, 5, 2, 12345);System.out.println(d);
这给了我们
de.fencing_game.paul.examples.DecimalBigInt@6af62373，而不是那么有用。因此，我们添加了一个
toString()方法：
public String toString() { return "Big" + Arrays.toString(digits);}现在的输出是
Big[7, 5, 2, 12345]，对于测试更有用，不是吗？
第二，从十进制格式转换。
我们在这里很幸运：我们的基数
（10 ^ 9）是我们要从（10）转换的基数的幂。因此，我们总是有相同的（9）个十进制数字代表一个“我们的格式”数字。（当然，开始时可能少一些数字。）在下面的代码中，decimal是一个十进制数字的字符串。
int decLen = decimal.length(); int bigLen = (decLen-1) / base_DECIMAL_DIGITS + 1;
这个奇怪的公式是Java int的编写方式
bigLen = ceil(decLen/base_DECIMAL_DIGITS)。（我希望它是正确的，我们稍后将对其进行测试。）
int firstSome = decLen - (bigLen-1) * base_DECIMAL_DIGITS;
这是第一位十进制数字的长度，应在1到9（含）之间。
我们创建数组：
int[] digits = new int[bigLen];
循环浏览要创建的数字：
for(int i = 0; i < bigLen ; i++) {我们的每个数字都由原始数字中的一个数字块表示：
String block = decimal.substring(Math.max(firstSome + (i-1)*base_DECIMAL_DIGITS, 0), firstSome + i *base_DECIMAL_DIGITS);
（Math.max这里是第一个较短的块在这里需要的。）现在，我们使用常规的Integer解析函数，并将结果放入数组中：
digits[i] = Integer.parseInt(block);}
从现在创建的数组中，我们创建DecimalBigInt对象：
return new DecimalBigInt(digits);
让我们看看这是否有效：
DecimalBigInt d2 = DecimalBigInt.valueOf("12345678901234567890");System.out.println(d2);输出：
Big[12, 345678901, 234567890]
看起来不错：-)我们也应该用其他一些数字（不同长度）对其进行测试。
下一部分将是十进制格式，这应该更加容易。
第三，转换为十进制格式。
我们需要将每个数字输出为9个十进制数字。为此，我们可以使用Formatter支持类printf格式字符串的类。
一个简单的变化就是：
public String toDecimalString() { Formatter f = new Formatter(); for(int digit : digits) { f.format("%09d", digit); } return f.toString();}对于我们的两个数字，这将返回
000000007000000005000000002000012345和
000000012345678901234567890。这适用于往返（即，将其馈送到
valueOf方法中会得到一个等效的对象），但前导零看起来并不太好看（并且可能与八进制数产生混淆）。因此，我们需要打破我们美丽的for-each循环，并使用不同的格式字符串作为前两位。
public String toDecimalString() { Formatter f = new Formatter(); f.format("%d", digits[0]); for(int i = 1 ; i < digits.length; i++) { f.format("%09d", digits[i]); } return f.toString();}Addition.
让我们从加法开始，因为它很简单（以后我们可以将其中的一部分用于乘法）。
public DecimalBigInt plus(DecimalBigInt that) { ...}我希望你能喜欢阅读，你会读的公式，从而方法名
plus，minus，times来代替
add，subtract，multiply。
那么，加法是如何工作的呢？它的工作原理与我们在学校学习到的十进制数字大于9时相同：加上相应的数字，如果其中某些数字大于10（或base在我们的情况下），则将一位带到下一位。这可能导致所得数字比原始数字多一位。
首先，我们来看一个简单的例子，即两个数字具有相同的数字位数。然后看起来就像这样：
int[] result = new int[this.digits.length];int carry = 0;for(int i = this.digits.length-1; i > 0; i--) { int digSum = carry + this.digits[i] + that.digits[i]; result[i] = digSum % base; carry = digSum / base;}if(carry > 0) { int[] temp = new int[result.length + 1]; System.arraycopy(result, 0, temp, 1, result.length); temp[0] = carry; result = temp;}return new DecimalBigInt(result);（我们从右到左移动，因此我们可以将所有溢出都带到下一位数字。如果我们决定使用Little Endian格式，这会有些漂亮。）
如果两个数字的位数不同，则会变得更加复杂。
为了使其尽可能简单，我们将其分为几种方法：
此方法将一位数字添加到数组中的元素（可能已经包含一些非零值），并将结果存储回数组中。如果有溢出，则通过递归调用将其带到下一个数字（索引少一个，而不是一个多）。这样，我们确保数字始终保持在有效范围内。
private void addDigit(int[] result, int resultIndex,int addendDigit){ int sum = result[resultIndex] + addendDigit; result[resultIndex] = sum % base; int carry = sum / base; if(carry > 0) { addDigit(result, resultIndex - 1, carry); }}下一个对要添加的整个数字数组执行相同的操作：
private void addDigits(int[] result, int resultIndex, int... addend){ addendIndex = addend.length - 1; while(addendIndex >= 0) { addDigit(result, resultIndex, addend[addendIndex]); addendIndex--; resultIndex--; }}现在我们可以实现我们的
plus方法：
public DecimalBigInt plus(DecimalBigInt that) { int[] result = new int[Math.max(this.digits.length, that.digits.length)+ 1]; addDigits(result, result.length-1, this.digits); addDigits(result, result.length-1, that.digits); // cut of leading zero, if any if(result[0] == 0) { result = Arrays.copyOfRange(result, 1, result.length); } return new DecimalBigInt(result);}如果可以在可能发生溢出之前先查看，然后再创建一个比所需数组大的数组，我们可以在这里做得更好。
啊，一个测试：
d2.plus(d2)给出
Big[24, 691357802, 469135780]，看起来不错。
乘法。
让我们记得回到学校时，我们如何在纸上乘以更大的数字？
123 * 123---------- 369 <== 123 * 3 246 <== 123 * 2 123 <== 123 * 1 -------- 15129
因此，我们必须将第一个数字的每个数字[i]与第二个数字的每个数字[j]相乘，并将乘积加到结果的数字[i + j]中（并注意携带）。当然，这里的索引是从右开始而不是从左开始计数。 （现在，我真的希望我能使用低端数字。）
由于我们两个数字的乘积可能超出的范围int，因此我们使用long乘法。
private void multiplyDigit(int[] result, int resultIndex, int firstFactor, int secondFactor) { long prod = (long)firstFactor * (long)secondFactor; int prodDigit = (int)(prod % base); int carry = (int)(prod / base); addDigits(result, resultIndex, carry, prodDigit);}现在我们可以看到为什么我声明我的
addDigits方法采用
resultIndex参数了。（我只是将最后一个参数更改为
varargs参数，以便能够在此处更好地编写。）
因此，这里是交叉乘法的方法：
private void multiplyDigits(int[] result, int resultIndex, int[] leftFactor, int[] rightFactor) { for(int i = 0; i < leftFactor.length; i++) { for(int j = 0; j < rightFactor.length; j++) { multiplyDigit(result, resultIndex - (i + j), leftFactor[leftFactor.length-i-1], rightFactor[rightFactor.length-j-1]); } }}我希望我的索引计算正确。如果使用小尾数表示法，那就
multiplyDigit(result, resultIndex + i + j, leftFactor[i], rightFactor[j])更清楚了，不是吗？
times现在，我们的方法只需分配结果数组，调用multiplyDigits并包装结果。
public DecimalBigInt times(DecimalBigInt that) { int[] result = new int[this.digits.length + that.digits.length]; multiplyDigits(result, result.length-1, this.digits, that.digits); // cut off leading zero, if any if(result[0] == 0) { result = Arrays.copyOfRange(result, 1, result.length); } return new DecimalBigInt(result);}对于测试，
d2.times(d2)给出
Big[152, 415787532, 388367501, 905199875, 19052100]，这与我的Emacs calc在此处计算的结果相同。
比较方式
我们希望能够比较我们的两个对象。因此，我们实现了Comparable
public int compareTo(DecimalBigInt that) {如何知道我们的一个数字是否大于另一个？首先，我们比较数组的长度。由于我们注意不要引入任何前导零（是吗？），因此较长的数组应具有较大的数字。
if(this.digits.length < that.digits.length) { return -1; } if (that.digits.length < this.digits.length) { return 1; }如果长度相同，我们可以按元素进行比较。由于我们使用big endian（即big end首先出现），因此我们从头开始。
for(int i = 0; i < this.digits.length; i++) { if(this.digits[i] < that.digits[i]) { return -1; } if(that.digits[i] < this.digits[i]) { return 1; } }如果一切都相同，那么显然我们的数字是相同的，我们可以返回0。
return 0;}equals + hashCode()
每一个良好的不可变类应该实现equals()和hashCode()在合适（兼容）的方式。
对于我们的hashCode()，我们只需对数字进行求和，然后将它们乘以一个小质数，以确保数字切换不会产生相同的哈希码：
public int hashCode() { int hash = 0; for(int digit : digits) { hash = hash * 13 + digit; } return hash;}在equals()方法中，我们可以简单地委托给compareTo方法，而不必再次实现相同的算法：
public boolean equals(Object o) { return o instanceof DecimalBigInt && this.compareTo((DecimalBigInt)o) == 0;}所以，今天足够了。减法（可能是负数）和除法更加复杂，因此我暂时将其省略。要计算90的阶乘，就足够了。
计算大阶乘：
这里的阶乘函数：
public static DecimalBigInt factorial(int n) { DecimalBigInt fac = new DecimalBigInt(1); for(int i = 2; i <= n; i++) { fac = fac.times(new DecimalBigInt(i)); } return fac;}这给了我们
fac(90) = 1485715964481761497309522733620825737885569961284688766942216863704985393094065876545992131370884059645617234469978112000000000000000000000
从任意基数表示形式转换
在下一个frodosamoa问题的提示下，我写了关于如何从任意（位置）数字系统转换为我们可以（或想要）进行计算的系统的答案。（在该示例中，我从三进制转换为十进制，而问题是从十进制转换为二进制。）
在这里，我们想从任意数字系统（好的，基数在2到36之间，所以我们可以用来将一位数字Character.digit()转换为整数）转换为带有基数base（= 1.000.000.000，但这在这里并不重要） 。
基本上，我们使用Horner方案来计算多项式的值，该数字在基数给定的点处作为系数。
sum[i=0..n] digit[i] * radix^i
可以使用以下循环计算：
value = 0;for i = n .. 0 value = value * radix + digit[i]return value
由于我们的输入字符串是big-endian，因此我们不必倒数，而是可以使用简单的增强型for循环。（在Java中看起来更难看，因为我们没有运算符重载，也没有从int到DecimalBigInt类型的自动装箱。）
public static DecimalBigInt valueOf(String text, int radix) { DecimalBigInt bigRadix = new DecimalBigInt(radix); DecimalBigInt value = new DecimalBigInt(); // 0 for(char digit : text.toCharArray()) { DecimalBigInt bigDigit =new DecimalBigInt(Character.digit(digit, radix)); value = value.times(bigRadix).plus(bigDigit); } return value;}在我的实际实现中，我添加了一些错误检查（和引发异常），以确保我们确实有一个有效的数字，当然还有文档注释。
转换为任意位置系统更为复杂，因为它涉及余数和除法（按任意基数），而我们尚未实现，因此目前还没有实现。当我对分割方法有个好主意时，它将完成。（在这里我们只需要用小数（一位数字）进行除法，这可能比一般的除法更容易。）
小数除法
在学校里，我学会了长除法。这是一个小（一位数字）除数的示例，我们在德国使用的表示法（带有关于背景计算的注释，通常不写），以十进制表示：
12345 : 6 = 02057 1 / 6 = 0-0┊┊┊┊ 0 * 6 = 0──┊┊┊┊ 12┊┊┊ 12 / 6 = 2-12┊┊┊ 2 * 6 = 12 ──┊┊┊ 03┊┊ 3 / 6 = 0 - 0┊┊ 0 * 6 = 0 ──┊┊ 34┊ 34 / 6 = 5 -30┊ 5 * 6 = 30 ──┊ 45 45 / 6 = 7 -42 7 * 6 = 42 ── 3 ==> quotient 2057, remainder 3.
当然，如果我们有本征余数运算，则不需要计算这些乘积（0、12、0、30、42）并减去它们。然后看起来像这样（当然，这里我们不需要编写操作）：
12345 : 6 = 02057 1 / 6 = 0, 1 % 6 = 1 12┊┊┊ 12 / 6 = 2, 12 % 6 = 0 03┊┊ 3 / 6 = 0, 3 % 6 = 3 34┊ 34 / 6 = 5, 34 % 6 = 4 45 45 / 6 = 7, 45 % 6 = 3 3==> quotient 2057, remainder 3.
如果我们用另一种格式编写的话，这看起来已经很像短除法了。
我们可以观察（并证明）以下内容：
如果我们有一个两位数的数字x，其第一位数字小于我们的除数d，x / d则它是一位数，并且x % d也是一位数字，小于d。这与归纳一起表明，我们只需要用除数除以两位数（余数）即可。
回到以base为基数的大数字：所有两位数字都可以用Java表示long，那里有native /和%。
private int divideDigit(int[] result, int resultIndex, int divident, int lastRemainder, int divisor) { assert divisor < base; assert lastRemainder < divisor; long ent = divident + (long)base * lastRemainder; long quot = ent / divisor; long rem = ent % divisor; assert quot < base; assert rem < divisor; result[resultIndex] = (int)quot; return (int)rem;}现在，我们将循环调用此方法，始终将前一次调用的结果反馈为lastRemainder。
private int divideDigits(int[] result, int resultIndex, int[] divident, int dividentIndex, int divisor) { int remainder = 0; for(; dividentIndex < divident.length; dividentIndex++, resultIndex++) { remainder = divideDigit(result, resultIndex, divident[dividentIndex], remainder, divisor); } return remainder;}此方法仍返回一个int，其余为。
现在我们要有一个返回DecimalBigInt的公共方法，所以我们创建一个。它的任务是检查参数，为工作方法创建一个数组，丢弃其余部分并从结果中创建DecimalBigInt。（构造函数删除可能存在的前导零。）
public DecimalBigInt divideBy(int divisor){ if(divisor <= 0 || base <= divisor) { throw new IllegalArgumentException("divisor " + divisor + " out of range!"); } int[] result = new int[digits.length]; divideDigits(result, 0, digits, 0, divisor); return new DecimalBigInt(result);}我们还有一个类似的方法，它返回余数：
public int modulo(int divisor) { if(divisor <= 0 || base <= divisor) { throw new IllegalArgumentException("divisor " + divisor + " out of range!"); } int[] result = new int[digits.length]; return divideDigits(result, 0, digits, 0, divisor);}这些方法可以这样调用：
DecimalBigInt d3_by_100 = d3.divideBy(100); System.out.println("d3/100 = " + d3_by_100); System.out.println("d3%100 = " + d3.modulo(100));转换为任意基数
现在我们有了转换为任意基数的基础。当然，不是真正任意的，只有基数小于base允许的基数，但这应该不是一个太大的问题。
正如在有关转换数字的另一个答案中已经回答的那样，我们必须执行“除法，余数，乘法，加法”。“乘加”部分实际上只是将各个数字放在一起，因此我们可以用一个简单的数组代替它-访问。
由于我们总是需要商和余数，因此我们将不使用public方法modulo和divideBy，而是反复调用该divideDigits方法。
public int[] convertTo(int radix){ if(radix <= 1 || base <= radix) { throw new IllegalArgumentException("radix " + radix + " out of range!"); }首先，特殊情况下处理0。
// zero has no digits. if(digits.length == 0) return new int[0];
然后，我们为结果数字（足够长）和一些其他变量创建一个数组。
// raw estimation how many output digits we will need. // This is just enough in cases like base-1, and up to // 30 digits (for base 2) too much for something like (1,0,0). int len = (int) (Math.log(base) / Math.log(radix) * digits.length)+1; int[] rDigits = new int[len]; int rIndex = len-1; int[] current = digits; int quotLen = digits.length;
quotLen是最后一个商的位数（不包括前导零）。如果为0，则完成。
while(quotLen > 0) {下一个商的新数组。
int[] quot = new int[quotLen];
商与余数运算。现在是商quot，其余为rem。
int rem = divideDigits(quot, 0, current, current.length - quotLen, radix);
我们将其余部分放在输出数组中（从最后一位开始填充）。
rDigits[rIndex] = rem; rIndex --;
然后我们将数组交换到下一轮。
current = quot;
如果商中有前导零（由于基数小于base，因为基数要小于1，所以最多为1），我们会将商大小缩小1。下一个数组将更小。
if(current[0] == 0) { // omit leading zeros in next round. quotLen--; } }循环之后，rDigits数组中可能有前导零，我们将其切除。
// cut of leading zeros in rDigits: while(rIndex < 0 || rDigits[rIndex] == 0) { rIndex++; } return Arrays.copyOfRange(rDigits, rIndex, rDigits.length);}而已。但是，它看起来有点复杂。这是一个如何使用它的示例：
System.out.println("d4 in base 11: " + Arrays.toString(d4.convertTo(11))); System.out.println("d5 in base 7: " + Arrays.toString(d5.convertTo(7)));它们打印
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]和[1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0]，与我们之前解析的数字相同（不过是从字符串中提取的）。
基于此，我们还可以将其格式化为字符串：
public String toString(int radix) { if(radix < Character.MIN_RADIX || Character.MAX_RADIX < radix) { throw new IllegalArgumentException("radix out of range: " + radix); } if(digits.length == 0) return "0"; int[] rdigits = convertTo(radix); StringBuilder b = new StringBuilder(rdigits.length); for(int dig : rdigits) { b.append(Character.forDigit(dig, radix)); } return b.toString();}
