实现大整数相加

如果两个很大很大的整数，大的连long类型都装不下（比如两个100位的整数），如何求出他们的和？
代码如下：

public class BigNumSum {
    public static void main(String [] args){
        System.out.println(bigNumberSum("72670975231800000001" ,"95481253129000000002"));
    }
    public static String bigNumberSum (String bigNumberA , String bigNumberB) {
        //1.把两个大整数用数组逆序存储，最高位存于数组长度-1下标位置,
        //之所以倒序存储，更加符合我们从左到右访问数组的习惯。
        //数组长度=整数长度+1，留一位空白循环计算时用
        int [] arrayA = new int [bigNumberA.length()+1];
        for(int i = 0; i < bigNumberA.length(); i++){
            //倒序将大整数存入int[]中，char类型转为int：char-'0'
            arrayA [i] = bigNumberA.charAt(bigNumberA.length()-1-i)-'0';
        }

        int [] arrayB = new int [bigNumberB.length()+1];
        for(int i = 0; i < bigNumberB.length(); i++){
            arrayB [i] = bigNumberB.charAt(bigNumberB.length()-1-i)-'0';
        }
        //2.构建result数组，数组长度等于较大整数位数+1
        int maxLength = bigNumberA.length() > bigNumberB.length()?bigNumberA.length():bigNumberB.length();
        int [] result = new int [maxLength+1];
        //3.遍历数组，按位相加
        for(int i = 0; i < result.length; i++){
            int temp = result [i];
            temp += arrayA [i];
            temp += arrayB [i];
            //判断是否进位
            if(temp >= 10 ){
                temp = temp - 10;
                result [i+1] = 1;
            }
            result [i] = temp;
        }
        //4.把result数组再次逆序并转成String
        StringBuilder sb = new StringBuilder();
        //是否找到大整数的最高有效位
        boolean findFirst = false;
        for(int i = result.length-1; i >= 0; i--){
            if(!findFirst){
                if(result [i] == 0){
                    continue;
                }
                findFirst = true;
            }
            sb.append(result [i]);
        }
        return sb.toString();
    }
}

运算结果如下图：

如何优化呢？
代码中把大整数按照每一个十进制数位来拆分，比如较大整数的长度有50位，那么我们需要创建一个51位的数组，数组的每个元素存储其中一位。
其实原整数拆分只需要拆分到可以被直接计算的程度就够了。
int类型的取值范围是 -2147483648——2147483647，最多有10位整数。为了防止溢出，我们可以把大整数的每9位作为数组的一个元素，进行加法运算。（这里也可以使用long类型来拆分，按照int范围拆分仅仅是提供一个思路）。
如此一来，占用空间和运算次数，都被压缩了9倍。