最近碰到大数乘法与大数加法的需求，如果直接用int类型会溢出。于是自己写了个大数乘法与大数加法的代码，就当自己练练手了。

1.大数加法

大数加法的逻辑相对乘法稍微简单一些。先将输入的两个字符串逆序生成字符数组，然后相同位上的字符相加保存在一个结果数组中。最后遍历结果数组，如果当前位的结果大于或等于10，则先将当前位的数值除以10加入下一位，当前位的值为取10的模。

看代码如下：

package leilei.bit.edu.bigNum;

public class AllNumAdd {

    public static String add(String s1,String s2) {
        //先将输入的两个串逆序生成字符数组
        char[] a = new StringBuilder(s1).reverse().toString().toCharArray();
        char[] b = new StringBuilder(s2).reverse().toString().toCharArray();

        //结果数组的最大长度为两个数组中长度较大的那个再加1
        int lenA = a.length;
        int lenB = b.length;
        int maxlen = lenA > lenB ? lenA : lenB;
        int[] result = new int[maxlen+1];

        //如果当前位超过了最大的长度，补0即可
        for(int i=0; i<maxlen+1; i++) {
            int aint = i < lenA ? (a[i] - '0') : 0;
            int bint = i < lenB ? (b[i] - '0') : 0;
            result[i] = aint + bint;
        }

        //遍历结果数组，大于10进位，当前位取10的模
        for(int i=0; i<result.length; i++) {
            if(result[i] >= 10) {
                result[i+1] += result[i] /10;
                result[i] %= 10;
            }
        }

        StringBuilder sb = new StringBuilder();
        if (result[maxlen] != 0) {
            sb.append(result[maxlen]);
        }

        for(int i=maxlen-1; i>=0; i--) {
            sb.append(result[i]);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String s1 = "1234567890";
        String s2 = "32110";
        String ret = add(s1,s2);
        System.out.println("ret is: " + ret);
    }

}

代码运行结果为:

ret is: 1234600000

2.大数乘法

大数乘法的逻辑相对加法稍微复杂一些。首先也先将输入的两个字符串逆序生成字符数组，假设两个字符串分别为A、B，则保存结果的数组长度为len(A)+len(B)。A的第i位于B的第j位的乘积，保存在结果数组的第i+j位上。将所有的计算结果计算完毕以后，再遍历结果数组进行进位处理。

package leilei.bit.edu.bigNum;

public class Multiply {

    public static String multiply(String s1,String s2) {
        //符号问题，如果两字符串异号，最后的结果为'-'
        char signA = s1.charAt(0);
        char signB = s2.charAt(0);
        char sign = '+';
        if(signA == '-' && signB != '-') {
            s1 = s1.substring(1);
            sign = signA;
        }
        if(signB == '-' && signA != '-') {
            s2 = s2.substring(1);
            sign = signB;
        }

        char[] a = new StringBuilder(s1).reverse().toString().toCharArray();
        char[] b = new StringBuilder(s2).reverse().toString().toCharArray();
        int lenA = a.length;
        int lenB = b.length;

        //结果数组
        int maxLen = lenA + lenB;
        int[] ret = new int[maxLen];

        //每一位分别相乘
        for(int i=0; i<lenA; i++) {
            for(int j=0; j<lenB; j++) {
                ret[i+j] += (a[i] - '0') * (b[j] - '0');
            }
        }

        //大于10，进位
        for(int i=0; i<ret.length; i++) {
            if(ret[i] >= 10) {
                ret[i+1] += ret[i] /10;
                ret[i] %= 10;
            }
        }

        //如果第一位为0，不输出
        StringBuilder sb = new StringBuilder();
        if(ret[ret.length-1] != 0) {
            sb.append(ret[ret.length-1]);
        }
        for(int i=ret.length-2; i>=0; i--) {
            sb.append(ret[i]);
        }
        if (sign == '-') { //如果是异号，在结果中插入'-'
            sb.insert(0, sign);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String s1 = "-999";
        String s2 = "100";
        String result = multiply(s1, s2);
        System.out.println("result is: " + result);
    }

}