字符串实现大数的相加

使用字符串实现大数的相加，包含负数，下面直接上代码，转载请注明出处：

/**
 * sum
 */
public class sum {

    public static String add(String n1, String n2) {
        String res ;
        if(n1.charAt(0) != '-' && n2.charAt(0) != '-') {
            res =  getSum(n1,n2);
        }else if(n1.charAt(0) == '-' && n2.charAt(0) == '-')
            res ="-"+ getSum(n1.substring(1), n2.substring(1));
        else {
            res = getMinus(n1,n2);
        }
        //System.out.println(res);
        return res;
    }

    public static String getSum(String n1, String n2){
        int l1 = n1.length();
        int l2 = n2.length();
        char[] res;
        boolean flag = false;

        //根据长度创建存储结果的字符数组，因为可能存在最高位想加进位的情况，长度+1
        if(l1 >= l2) {
            res = new char[l1+1];
            flag = true;
        }  else{
            res = new char[l2+1];
        }
        
        int pos = res.length - 1; 
        int takeOver = 0;
        l1 --;
        l2 --;
        //从最低位开始相加，直到其中一个已经求和结束
        while(l1 >= 0 && l2 >= 0){
            int sum = n1.charAt(l1) - '0' + n2.charAt(l2) - '0' + takeOver;
            takeOver = 0;
            if(sum >= 10){
                res[pos] = (char) (sum - 10+ '0');
                takeOver = 1;
            } else {
                res[pos] = (char) (sum+ '0');
            }
            l1 --;
            l2 --;
            pos --;
        }

        //把剩下的字符串复制到结果res,注意可能出现的tackOver进位存在
        if (flag) {
            while (l1 >= 0 && pos >= 0) {
                int sum = n1.charAt(l1) - '0' + takeOver;
                takeOver = 0;
                if(sum >= 10){
                    res[pos] = (char) (sum - 10 + '0');
                    takeOver = 1;
                } else {
                    res[pos] = (char) (sum + '0');
                }
                l1 --;
                pos --;
            }
        } else {
            while (l2 >= 0 && pos >= 0) {
                int sum = n2.charAt(l1) - '0' + takeOver;
                takeOver = 0;
                if(sum >= 10){
                    res[pos] = (char) (sum - 10 + '0');
                    takeOver = 1;
                } else {
                    res[pos] = (char) (sum+ '0');
                }
                l2 --;
                pos --;
            }
        }
        //如果两个字符串的长度相等，那么就需要考虑向最高位进位的情况，这里要加上进位
        res[pos] = (char) ('0' + takeOver);

        String str = new String(res);
        //对开始为0的情况需要处理
        if (str.charAt(0) == '0') {
            str = str.substring(1);
        }
        return str;
    }

    public static String getMinus( String n1, String n2){
        boolean n1Nagative = false; // n1 is -
        boolean n2Nagative = false; // n2 is -
        boolean isLarger = false;
        boolean isNagative = false;
        String  res = null;
        //判断n1是否为负数，并取出数值部分
        if(n1.charAt(0) == '-') {
            n1Nagative = true;
            n1 =  n1.substring(1);
        }
        //判断n2是否为负数，并取出数值部分
        if (n2.charAt(0) == '-') {
            n2Nagative = true;
            n2 = n2.substring(1);
        }
        if(n1Nagative){
            //判断n1是否大于n2，如果大于，那么结果为负值
            isLarger = isLarger(n1,n2);
            if (isLarger) {
                isNagative = true;
                res = bigDigitalSub(n1, n2);//实现n1 - n2 
            } else {
                isNagative = false; //此时结果为正，n2 > n1
                res = bigDigitalSub(n2, n1); //实现n2 - n1
            }
        } 
        if(n2Nagative) {
            //判断n2是否大于n1，如果大于，那么结果为负值
            isLarger = isLarger(n2,n1);
            if (isLarger) { //n2 > n1;
                isNagative = true;
                res = bigDigitalSub(n2, n1);//实现n2 - n1
            } else {
                isNagative = false;//此时结果为正，n1 > n2
                res = bigDigitalSub(n1, n2);//实现n1 - n2 
            }
        }
        return isNagative?"-" + res:res;
    }
    public static String bigDigitalSub(String a, String b){
        //翻转字符串并转化成数组
        char[] aArray = new StringBuilder(a).reverse().toString().toCharArray();
        char[] bArray = new StringBuilder(b).reverse().toString().toCharArray();
        int aLength = aArray.length;
        int bLength = bArray.length;
         //找到最大的位数，两个整数的差的位数小于等于两个整数中的最大位数
         int maxLength = aLength > bLength ? aLength : bLength;
         int[] result = new int[maxLength];
         //开始计算结果集
        for (int i = 0; i < maxLength; i++) {
            int aInt = i < aLength ? aArray[i] - '0' : 0;
            int bInt = i < bLength ? bArray[i] - '0' : 0;
            // if (sign == '-') result[i] = bInt - aInt;
            // else result[i] = aInt - bInt;
            result[i] = aInt - bInt;
        }
        //处理结果集，如果结果集中的某一位小于0，则向高位借位，然后将本位加10
        for (int i = 0; i < maxLength - 1; i++) {
            if (result[i] < 0) {
                result[i + 1] -= 1;
                result[i] += 10;
            }
        }
        //处理结果集，转化成真正结果
        StringBuffer realResult = new StringBuffer();
        boolean isBeginning = true;
        for (int i = maxLength - 1; i >= 0; i--) {
            if (result[i] == 0 && isBeginning) continue;
            else isBeginning = false;
            realResult.append(result[i]);
        }
        if (realResult.toString().equals("")) realResult.append('0');
        return realResult.toString();
    }

    public static boolean isLarger(String n1, String n2){
        boolean res= false;
        if (n1.length() > n2.length()) {
            res = true; // n1 > n2
        } else if (n1.length() ==  n2.length()) {
            for(int i = 0; i < n1.length(); i++){
                if (n1.charAt(i) < n2.charAt(i)) {
                    res =  false; //n2 > n1
                    break;
                }
            }
            res =  true;
        } else if(n1.length() < n2.length()) {
            res =  false; // n2 > n1;
        }
        return res;
    }
    public static void main(String[] args) {
        String n1 = "12345";
        String n2 = "-112300";
        System.out.println(add(n1, n2));
    }
}