原理：
用数组存储数字，按照计算法则进行运算。
代码：
package com.hdwang; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * 大数四则运算（超出long型的大数（64位：18446744073709551615）） * Created by hdwang on 2017/10/9. */ public class Calculator { /** * 两数相加 * @param numStr1 数1 * @param numStr2 数2 * @return 结果 */ public static String add(String numStr1, String numStr2){ int numLen1 = numStr1.length(); int numLen2 = numStr2.length(); int[] numArray1 = new int[numLen1]; //数字数组 int[] numArray2 = new int[numLen2]; // "12345"-> [5,4,3,2,1] for(int i=0;i<numLen1;i++){ String c = numStr1.substring(i,i+1); numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } for(int i=0;i<numLen2;i++){ String c = numStr2.substring(i,i+1); numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } int minLen = 0; //取长度小的数位数 int maxLen = 0; //取长度大的数位数 int[] maxArray = null; //长度大的数 if(numLen1<numLen2){ minLen = numLen1; maxLen = numLen2; maxArray = numArray2; }else{ minLen = numLen2; maxLen = numLen1; maxArray = numArray1; } int[] resultArray = new int[maxLen+1]; //考虑到可能会进位，多给一个元素空间 //两数长度相同的部分，同位相加，超出9进1 int added = 0; int i=0; for(;i<minLen;i++){ int t = numArray1[i]+numArray2[i]+added; //两数相加，再加进位 if(t>9){ added = 1; //进1 resultArray[i] = t-10; //当前位计算结果 }else{ added = 0; //不进位 resultArray[i] = t; //当前位计算结果 } } //长度超出部分累加 for(;i<maxLen;i++){ int t = maxArray[i]+added; //多余位数加上进位 if(t>9){ added = 1; //进1 resultArray[i] = t-10; //当前位计算结果 }else{ added = 0; //不进位 resultArray[i] = t; //当前位计算结果 } } resultArray[i] = added; //最高位 //拼接结果 [1,4,8,2,0] -> 2841 StringBuilder builder = new StringBuilder(); for(int n=resultArray.length-1;n>=0;n--){ //如果最高位为0,移除 if(n==resultArray.length-1 && resultArray[resultArray.length-1]==0){ continue; //跳过 }else{ builder.append(resultArray[n]); } } return builder.toString(); } /** * 两数相减 * @param numStr1 数1 * @param numStr2 数2 * @return 结果 */ public static String subtract(String numStr1,String numStr2){ int numLen1 = numStr1.length(); int numLen2 = numStr2.length(); int[] numArray1 = new int[numLen1]; //数字数组 int[] numArray2 = new int[numLen2]; // "12345"-> [5,4,3,2,1] for(int i=0;i<numLen1;i++){ String c = numStr1.substring(i,i+1); numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } for(int i=0;i<numLen2;i++){ String c = numStr2.substring(i,i+1); numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } int minLen = 0; //取长度小的数位数 int maxLen = 0; //取长度大的数位数 int[] maxArray = null; //数值大的数 if(numLen1<numLen2){ minLen = numLen1; maxLen = numLen2; maxArray = numArray2; }else{ minLen = numLen2; maxLen = numLen1; maxArray = numArray1; if(numLen1 == numLen2){ //等于 maxArray = getMaxNumber(numArray1,numArray2); } } int[] minArray = maxArray==numArray1?numArray2:numArray1; //数值小的数 int[] resultArray = new int[maxLen]; //大数-小数，同位相减，小于0借位 int subtracted = 0; int i=0; for(;i<minLen;i++){ int t = maxArray[i] - minArray[i] - subtracted; //两数相减，再减借位 if(t<0){ subtracted = 1; //向高位借1，暂存起来 resultArray[i] = t+10; //当前位计算结果（借1相当于借了10） }else{ subtracted = 0; //不借位 resultArray[i] = t; //当前位计算结果 } } //大数超出部分减掉借位 for(;i<maxLen;i++){ int t = maxArray[i]-subtracted; //多余位数减掉借位 if(t<0){ subtracted = 1; //进1 resultArray[i] = t+10; //当前位计算结果 }else{ subtracted = 0; //不借位 resultArray[i] = t; //当前位计算结果 } } //拼接结果 [1,4,8,2,0] -> 2841 StringBuilder builder = new StringBuilder(); boolean highBitNotEqualZero = false; //存在高位不为0的情况，低位0保留 for(int n=resultArray.length-1;n>=0;n--){ //如果高位为0,移除 if(resultArray[n]==0 && !highBitNotEqualZero && n!=0){ //高位无用的0去除 continue; //跳过 }else{ highBitNotEqualZero = true; //找到不为0的位 builder.append(resultArray[n]); } } if(maxArray == numArray1){ //第一个数大或相等 }else{ //第一个数小于第二个数，相减为负数 builder.insert(0,"-"); } return builder.toString(); } /** * 两数相乘 * @param numStr1 数1 * @param numStr2 数2 * @return 结果 */ public static String multiply(String numStr1,String numStr2){ int numLen1 = numStr1.length(); int numLen2 = numStr2.length(); int[] numArray1 = new int[numLen1]; //数字数组 int[] numArray2 = new int[numLen2]; // "12345"-> [5,4,3,2,1] for(int i=0;i<numLen1;i++){ String c = numStr1.substring(i,i+1); numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } for(int i=0;i<numLen2;i++){ String c = numStr2.substring(i,i+1); numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } int minLen = 0; //取长度小的数位数 int maxLen = 0; //取长度大的数位数 int[] maxArray = null; //长度大的数 int[] minArray = null; //长度小的数 if(numLen1<numLen2){ minLen = numLen1; maxLen = numLen2; minArray = numArray1; maxArray = numArray2; }else{ minLen = numLen2; maxLen = numLen1; minArray = numArray2; maxArray = numArray1; } //二维数组存储结果，例如：23*23 ->[[6,9],[4,6]] ,内部括号（低维）存某位的相乘结果，高维低位存个位,十位... int[][] resultArray = new int[minLen][maxLen+1]; //长度大的数*长度小的数的每一位，分别存到相应数组中，然后累加 for(int h=0;h<minLen;h++){ //高维 int l=0; int added = 0; for(;l<maxLen;l++){ //低维 int t = maxArray[l]*minArray[h]+added; //长度大的数的每一位*长度小的数的个位、十位... if(t>9){ added = t/10; //进位 resultArray[h][l] = t%10; //当前位计算结果 }else{ added = 0; //不进位 resultArray[h][l] = t; //当前位计算结果 } } resultArray[h][l] = added; //个位、十位...的计算结果的最高位 } //对结果补位（左移），个位不动，十位补0，百位补00...，然后累加 int[] sum = null; //最终累加结果 int[] lowBitResult = null; //低位补0结果（前一位） for(int h=0;h<minLen;h++){ int[] bitResult = resultArray[h]; int[] r; //个位、十位...的补0结果 if(h==0){ //个位 r = bitResult; sum = r; lowBitResult = r; //记录下来，待下次循环累加 }else{ //十位...的计算结果 r = new int[resultArray[h].length+h]; //初始化默认就是0的 int rLen = r.length-1; for(int i=bitResult.length-1;i>=0;i--){ //从高位开始复制到新数组 r[rLen--] = bitResult[i]; } //累加之前的数 sum = new int[r.length+1]; //取高位长度+1，可能进位 //================加法核心算法==================== //两数长度相同的部分，同位相加，超出9进1 int added = 0; int i=0; for(;i<lowBitResult.length;i++){ int t = lowBitResult[i]+r[i]+added; //两数相加，再加进位 if(t>9){ added = 1; //进1 sum[i] = t-10; //当前位计算结果 }else{ added = 0; //不进位 sum[i] = t; //当前位计算结果 } } //长度超出部分累加 for(;i<r.length;i++){ int t = r[i]+added; //多余位数加上进位 if(t>9){ added = 1; //进1 sum[i] = t-10; //当前位计算结果 }else{ added = 0; //不进位 sum[i] = t; //当前位计算结果 } } sum[i] = added; //最高位 //=============================================== lowBitResult = sum; //记录下来，待下次循环累加 } } //拼接结果 [1,4,8,2,0] -> 2841 StringBuilder builder = new StringBuilder(); boolean existHighNotZero = false; //高位存在不为0的，这个0就不能移除 for(int n=sum.length-1;n>=0;n--){ //移除高位无效的0，保留最后一个0 if(sum[n]==0 && !existHighNotZero && n!=0){ continue; //跳过 }else{ existHighNotZero = true; builder.append(sum[n]); } } return builder.toString(); } /** * 两数相除 * @param numStr1 数1(被除数) * @param numStr2 数2(除数,不能超过long型) * @return 结果 */ public static String divide(String numStr1,String numStr2){ int numLen1 = numStr1.length(); int numLen2 = numStr2.length(); int[] numArray1 = new int[numLen1]; //数字数组 int[] numArray2 = new int[numLen2]; // "12345"-> [5,4,3,2,1] for(int i=0;i<numLen1;i++){ String c = numStr1.substring(i,i+1); numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } for(int i=0;i<numLen2;i++){ String c = numStr2.substring(i,i+1); numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认大数长度+16 int[] resultArray = new int[effectiveNum]; //高位存高位 //将被除数的每一位除以除数，取整为该位结果，取余暂存借给低位(除数不能大过long型，除非除法转换为减法) long yu = 0; int resultIndex = effectiveNum-1; for(int i=numArray1.length-1;i>=0;i--){ long num = yu * 10 + numArray1[i]; //被除数该位为：余数*10+自己 int r= (int)(num / Long.parseLong(numStr2)); //取整 yu = num % Long.parseLong(numStr2); //取余 resultArray[resultIndex--] = r; } int decimalPoint = effectiveNum-numArray1.length-1; //小数点位置 if(yu!=0){ int decimal = decimalPoint; //小数 for(int i=0;i<effectiveNum-numArray1.length;i++){ long num = yu * 10 + 0; //小数部分被除数补0 int r= (int)(num / Long.parseLong(numStr2)); //取整 yu = num % Long.parseLong(numStr2); //取余 resultArray[decimal--] = r; if(yu==0){ break; //余数为0，提前退出 } } } //拼接结果 StringBuilder builder = new StringBuilder(); boolean existHighNotZero = false; for(int i=effectiveNum-1;i>=0;i--){ if(i==decimalPoint){ builder.append("."); } if(resultArray[i]==0){ if(!existHighNotZero && i>decimalPoint+1){ //跳过高位无用的0 continue; } }else{ existHighNotZero = true; } builder.append(resultArray[i]); } String result = builder.toString(); //去除尾部无用的0 int endIndex = result.length(); for(int i=result.length()-1;i>=0;i--){ char c = result.charAt(i); if(c!='0'){ endIndex = i+1; break; } } //去除多余的小数点 if(result.charAt(endIndex-1)=='.'){ endIndex = endIndex-1; } result = result.substring(0,endIndex); return result; } /** * 两数相除（增强版） * @param numStr1 数1(被除数) * @param numStr2 数2(除数) * @return 结果 */ public static String divideEnhanced(String numStr1,String numStr2){ int numLen1 = numStr1.length(); int numLen2 = numStr2.length(); int[] numArray1 = new int[numLen1]; //数字数组 int[] numArray2 = new int[numLen2]; // "12345"-> [5,4,3,2,1] for(int i=0;i<numLen1;i++){ String c = numStr1.substring(i,i+1); numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } for(int i=0;i<numLen2;i++){ String c = numStr2.substring(i,i+1); numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字 } int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认大数长度+16 int[] resultArray = new int[effectiveNum]; //高位存高位 //将被除数的每一位除以除数，取整为该位结果，取余暂存借给低位(除数不能大过long型，除非除法转换为减法) String yu = "0"; int resultIndex = effectiveNum-1; for(int i=numArray1.length-1;i>=0;i--){ String num = "0".equals(yu)?numArray1[i]+"":add(yu+"0",numArray1[i]+""); //被除数该位为：余数*10+自己 DivideResult result = getDivideResult(num,numStr2); String r= result.getR() ; //取整 yu = result.getYu(); //取余 resultArray[resultIndex--] = Integer.parseInt(r); //某位上的结果肯定小于10 } int decimalPoint = effectiveNum-numArray1.length-1; //小数点位置 if(!"0".equals(yu)){ int decimal = decimalPoint; //小数 for(int i=0;i<effectiveNum-numArray1.length;i++){ String num = yu+"0"; //小数部分被除数补0 DivideResult result = getDivideResult(num,numStr2); String r= result.getR() ; //取整 yu = result.getYu(); //取余 resultArray[decimal--] = Integer.parseInt(r); if("0".equals(yu)){ break; //余数为0，提前退出 } } } //拼接结果 StringBuilder builder = new StringBuilder(); boolean existHighNotZero = false; for(int i=effectiveNum-1;i>=0;i--){ if(i==decimalPoint){ builder.append("."); } if(resultArray[i]==0){ if(!existHighNotZero && i>decimalPoint+1){ //跳过高位无用的0 continue; } }else{ existHighNotZero = true; } builder.append(resultArray[i]); } String result = builder.toString(); //去除尾部无用的0 int endIndex = result.length(); for(int i=result.length()-1;i>=0;i--){ char c = result.charAt(i); if(c!='0'){ endIndex = i+1; break; } } //去除多余的小数点 if(result.charAt(endIndex-1)=='.'){ endIndex = endIndex-1; } result = result.substring(0,endIndex); return result; } /** * 校验数字是否合法 * @param numStr 数字字符串 * @return 是否合法 */ public static boolean numberValid(String numStr){ Pattern pattern = Pattern.compile("^[1-9]\d*$|0"); Matcher matcher = pattern.matcher(numStr); return matcher.matches(); } /** * 计算大数 * @param numArray1 数1 * @param numArray2 数2 * @return 大数 */ public static int[] getMaxNumber(int[] numArray1, int[] numArray2) { for(int i=numArray1.length-1;i>=0;i--){ if(numArray1[i]>numArray2[i]){ return numArray1; }else{ if(numArray1[i]==numArray2[i]){ continue; //待继续比较 }else{ return numArray2; } } } return numArray1; //全部相等，返回第一个 } /** * 除法转换为减法 * @param numStr1 数1（被除数） * @param numStr2 数2（除数） * @return 除的结果 */ public static DivideResult getDivideResult(String numStr1,String numStr2){ DivideResult result = new DivideResult(); String r = ""; // String times = "0"; int times = 0; //取整不会大于9的（被除数（余数+某位）/除数(肯定大于余数)这个过程是，被除数逐渐增大到可以除以除数为止，此时被除数>=除数，刚刚好，所以被除数最多比除数多1位，两数相差肯定小于10倍） while (true){ r=subtract(numStr1,numStr2); // times = add(times,"1"); //次数递增 times++; if("0".equals(r)){ //除尽了 result.setYu("0"); result.setR(times+""); break; }else if(r.startsWith("-")){ //负数，多减了一次 result.setYu(numStr1); //上次减下来多余的数值，就是余数 // result.setR(subtract(times,"1")); result.setR((times-1)+""); break; } numStr1 = r; //被减数重置为剩余的数值 } return result; } }
package com.hdwang; /** * Created by hdwang on 2017/10/10. * 相除结果 */ public class DivideResult { /** * 取整结果 */ private String r; /** * 取余结果 */ private String yu; public String getR() { return r; } public void setR(String r) { this.r = r; } public String getYu() { return yu; } public void setYu(String yu) { this.yu = yu; } }
package com.hdwang; import java.util.Scanner; import static com.hdwang.Calculator.*; public class Main { public static void main(String[] args) { // write your code here Scanner scanner = new Scanner(System.in); boolean loop = true; while (loop) { System.out.println("请输入第一个非负整数："); String numStr1 = scanner.nextLine(); if (!numberValid(numStr1)) { System.out.println(String.format("%s不合法", numStr1)); continue; } System.out.println("请输入第二个非负整数："); String numStr2 = scanner.nextLine(); if (!numberValid(numStr2)) { System.out.println(String.format("%s不合法", numStr2)); continue; } String r1 = add(numStr1, numStr2); System.out.println(String.format("大数加法计算：%s+%s%s=%s", numStr1, numStr2,r1.length()>50?" ":"", r1)); try { System.out.println("加法直接计算：" + (Long.parseLong(numStr1) + Long.parseLong(numStr2))); }catch (Exception ex){ System.out.println("加法直接计算："+ex.getClass().getName()); } String r2 = subtract(numStr1, numStr2); System.out.println(String.format("大数减法计算：%s-%s%s=%s", numStr1, numStr2,r2.length()>50?" ":"", r2)); try { System.out.println("减法直接计算：" + (Long.parseLong(numStr1) - Long.parseLong(numStr2))); }catch (Exception ex){ System.out.println("减法直接计算："+ex.getClass().getName()); } String r3 = multiply(numStr1, numStr2); System.out.println(String.format("大数乘法计算：%s*%s%s=%s", numStr1, numStr2,r3.length()>50?" ":"", r3)); try { System.out.println("乘法直接计算：" + (Long.parseLong(numStr1) * Long.parseLong(numStr2))); }catch (Exception ex){ System.out.println("乘法直接计算："+ex.getClass().getName()); } try { String r4 = divide(numStr1, numStr2); System.out.println(String.format("大数除法计算：%s/%s%s=%s", numStr1, numStr2, r4.length() > 50 ? " " : "", r4)); }catch (Exception ex){ System.out.println("大数除法计算："+ex.getClass().getName()); } try { System.out.println("除法直接计算：" + ((double)Long.parseLong(numStr1) / (double) Long.parseLong(numStr2))); }catch (Exception ex){ System.out.println("除法直接计算："+ex.getClass().getName()); } String r5 = divideEnhanced(numStr1, numStr2); System.out.println(String.format("增强版大数除法计算：%s/%s%s=%s", numStr1, numStr2,r5.length()>50?" ":"", r5)); System.out.println("退出输入q，否则继续"); String line = scanner.nextLine(); if(line.equalsIgnoreCase("Q")){ loop = false; }else{ loop = true; } } } }
运行结果：
请输入第一个非负整数： 1 请输入第二个非负整数： 1 大数加法计算：1+1=2 加法直接计算：2 大数减法计算：1-1=0 减法直接计算：0 大数乘法计算：1*1=1 乘法直接计算：1 大数除法计算：1/1=1 除法直接计算：1.0 增强版大数除法计算：1/1=1 退出输入q，否则继续 请输入第一个非负整数： 2 请输入第二个非负整数： 3 大数加法计算：2+3=5 加法直接计算：5 大数减法计算：2-3=-1 减法直接计算：-1 大数乘法计算：2*3=6 乘法直接计算：6 大数除法计算：2/3=0.6666666666666666 除法直接计算：0.6666666666666666 增强版大数除法计算：2/3=0.6666666666666666 退出输入q，否则继续 请输入第一个非负整数： 25 请输入第二个非负整数： 25 大数加法计算：25+25=50 加法直接计算：50 大数减法计算：25-25=0 减法直接计算：0 大数乘法计算：25*25=625 乘法直接计算：625 大数除法计算：25/25=1 除法直接计算：1.0 增强版大数除法计算：25/25=1 退出输入q，否则继续 请输入第一个非负整数： 100 请输入第二个非负整数： 50 大数加法计算：100+50=150 加法直接计算：150 大数减法计算：100-50=50 减法直接计算：50 大数乘法计算：100*50=5000 乘法直接计算：5000 大数除法计算：100/50=2 除法直接计算：2.0 增强版大数除法计算：100/50=2 退出输入q，否则继续 请输入第一个非负整数： 3 请输入第二个非负整数： 4 大数加法计算：3+4=7 加法直接计算：7 大数减法计算：3-4=-1 减法直接计算：-1 大数乘法计算：3*4=12 乘法直接计算：12 大数除法计算：3/4=0.75 除法直接计算：0.75 增强版大数除法计算：3/4=0.75 退出输入q，否则继续 请输入第一个非负整数： 4 请输入第二个非负整数： 3 大数加法计算：4+3=7 加法直接计算：7 大数减法计算：4-3=1 减法直接计算：1 大数乘法计算：4*3=12 乘法直接计算：12 大数除法计算：4/3=1.3333333333333333 除法直接计算：1.3333333333333333 增强版大数除法计算：4/3=1.3333333333333333 退出输入q，否则继续 请输入第一个非负整数： 1 请输入第二个非负整数： 100 大数加法计算：1+100=101 加法直接计算：101 大数减法计算：1-100=-99 减法直接计算：-99 大数乘法计算：1*100=100 乘法直接计算：100 大数除法计算：1/100=0.01 除法直接计算：0.01 增强版大数除法计算：1/100=0.01 退出输入q，否则继续 请输入第一个非负整数： 100 请输入第二个非负整数： 1 大数加法计算：100+1=101 加法直接计算：101 大数减法计算：100-1=99 减法直接计算：99 大数乘法计算：100*1=100 乘法直接计算：100 大数除法计算：100/1=100 除法直接计算：100.0 增强版大数除法计算：100/1=100 退出输入q，否则继续 请输入第一个非负整数： 1 请输入第二个非负整数： 10000000000 大数加法计算：1+10000000000=10000000001 加法直接计算：10000000001 大数减法计算：1-10000000000=-9999999999 减法直接计算：-9999999999 大数乘法计算：1*10000000000=10000000000 乘法直接计算：10000000000 大数除法计算：1/10000000000=0.0000000001 除法直接计算：1.0E-10 增强版大数除法计算：1/10000000000=0.0000000001 退出输入q，否则继续 请输入第一个非负整数： 1 请输入第二个非负整数： 100000000000000000000000000000000000000000000000000 大数加法计算：1+100000000000000000000000000000000000000000000000000 =100000000000000000000000000000000000000000000000001 加法直接计算：java.lang.NumberFormatException 大数减法计算：1-100000000000000000000000000000000000000000000000000 =-99999999999999999999999999999999999999999999999999 减法直接计算：java.lang.NumberFormatException 大数乘法计算：1*100000000000000000000000000000000000000000000000000 =100000000000000000000000000000000000000000000000000 乘法直接计算：java.lang.NumberFormatException 大数除法计算：java.lang.NumberFormatException 除法直接计算：java.lang.NumberFormatException 增强版大数除法计算：1/100000000000000000000000000000000000000000000000000 =0.00000000000000000000000000000000000000000000000001 退出输入q，否则继续
说明：
当数字的大小超过long类型的数值范围时，将无法对数值进行计算，所以必须实现一套算法。曾经上C语言程序设计时做的一套课程设计就是这个题目，当时苦于能力不足，写不起来。如今，用java写出来了加减运算，经过多次测试，准确无误。耗时8.5小时完成，哈哈。至于小数计算，可以转换成整数计算，然后移动小数点位置即可。至于符号带符号的运算也简单，乘除法负负得正，正负得负，正正得正，带负号的加减法可以转换为不待负号的运算。例如：-a-b=-(a+b) ; -a-(-b) = b-a; -a + -b = -(a+b) 等