大数加减法-java实现

计算机的各种数据类型的存储范围有限 在特大数的处理方面 也许需要我们自己去实现

这里就给大家介绍下 大数的加减法处理

大数加法

基本思想是将两个特大的整数利用字符数组作为存储介质 对原有数进行翻转处理 逐位计算 遍历结果逢十进一

代码如下

 private static String add(String a, String b) {
        char[] aa = new StringBuffer(a).reverse().toString().toCharArray();
        char[] bb = new StringBuffer(b).reverse().toString().toCharArray();
        int aLen = aa.length;
        int bLen = bb.length;
        int len = aLen > bLen ? aLen : bLen;

        int[] result = new int[len + 1];
        for (int i = 0; i < len + 1; ++i) {
            int aint = i < aLen ? aa[i] - '0' : 0;
            int bint = i < bLen ? bb[i] - '0' : 0;
            result[i] = aint + bint;
        }

        for(int i=0;i=10){
                result[i+1] += result[i]/10;
                result[i] %= 10;
            }
        }

        boolean flag = true;
        StringBuffer sb = new StringBuffer(len);
        for(int i=len;i>=0;--i){
            if(result[i]==0&&flag){
                continue;
            }else{
                flag=false;
            }
            sb.append(result[i]);
        }
        return sb.toString();
    }

大数减法

基本思想其实跟大数加法类似 只是多了一层符号的计算 两个数的比较 逐位判断如果是负数就借位求和

public static String sub(String f, String s) {
        System.out.print("减法:" + f + "-" + s + "=");
        // 将字符串翻转并转换成字符数组
        char[] a = new StringBuffer(f).reverse().toString().toCharArray();
        char[] b = new StringBuffer(s).reverse().toString().toCharArray();
        int lenA = a.length;
        int lenB = b.length;
        // 找到最大长度
        int len = lenA > lenB ? lenA : lenB;
        int[] result = new int[len];
        // 表示结果的正负
        char sign = '+';
        // 判断最终结果的正负
        if (lenA < lenB) {
            sign = '-';
        } else if (lenA == lenB) {
            int i = lenA - 1;
            while (i > 0 && a[i] == b[i]) {
                i--;
            }
            if (a[i] < b[i]) {
                sign = '-';
            }
        }
        // 计算结果集，如果最终结果为正，那么就a-b否则的话就b-a
        for (int i = 0; i < len; i++) {
            int aint = i < lenA ? (a[i] - '0') : 0;
            int bint = i < lenB ? (b[i] - '0') : 0;
            if (sign == '+') {
                result[i] = aint - bint;
            } else {
                result[i] = bint - aint;
            }
        }
        // 如果结果集合中的某一位小于零，那么就向前一位借一，然后将本位加上10。其实就相当于借位做减法
        for (int i = 0; i < result.length - 1; i++) {
            if (result[i] < 0) {
                result[i + 1] -= 1;
                result[i] += 10;
            }
        }

        StringBuffer sb = new StringBuffer();
        // 如果最终结果为负值，就将负号放在最前面，正号则不需要
        if (sign == '-') {
            sb.append('-');
        }
        // 判断是否有前置0
        boolean flag = true;
        for (int i = len - 1; i >= 0; i--) {
            if (result[i] == 0 && flag) {
                continue;
            } else {
                flag = false;
            }
            sb.append(result[i]);
        }
        // 如果最终结果集合中没有值，就说明是两值相等，最终返回0
        if (sb.toString().equals("")) {
            sb.append("0");
        }
        // 返回值
        System.out.println(sb.toString());
        return sb.toString();
    }

ps:如果是带小数的大数计算暂没有考虑,两个负数的大数计算可以转化为两个大数的加再加上符号