java算法0~大数相加

思路：（我们不用java的BigDecimal来操作）

　　1.反转两个字符串，便于从低位到高位相加和最高位的进位导致和的位数增加；

      2.对齐两个字符串，即短字符串的高位用‘0’补齐，便于后面的相加；

      3.把两个正整数相加，一位一位的加并加上进位。

package test_technology;

/**
 *
 * @author zhengchao
 */
public class BigIntAdd {
    
    /**
     * 用字符串模拟两个大数相加:前提两个都是正整数，当然你可以直接用BIGDECIMAL对象来计算
     * @param n1 加数1
     * @param n2 加数2
     * @return   相加结果
     */
    public static String bigAdd(String n1,String n2){
        
        StringBuffer result = new StringBuffer();

        //1、反转字符串
        n1 = new StringBuffer(n1).reverse().toString();    
        n2 = new StringBuffer(n2).reverse().toString();

        int len1 = n1.length();
        int len2 = n2.length();
        int maxLen = len1 > len2 ? len1 : len2;
        boolean nOverFlow = false; //是否大于10，大于10需要进位

        //2.把两个字符串补齐，即短字符串的高位用0补齐
        if(len1 < len2){
            for(int i = len1 ; i < len2 ; i++){
                n1 += "0";
            }
        }
        else if (len1 > len2){
            for(int i = len2 ; i < len1 ; i++){
                n2 += "0";
            }
        }

        //3.把两个正整数相加，一位一位的加并加上进位
        for(int i = 0 ; i < maxLen ; i++){
            int nSum = Integer.parseInt(n1.charAt(i) +"") + Integer.parseInt(n2.charAt(i) +"");
            
            if(nSum<=9){
                if(nOverFlow==true){  //低位上一次有进位
                    if(nSum==9){
                        result.append(0);
                        nOverFlow=true;  //本次有进位，由于本来就是true，无需修改
                    }else{
                        result.append(nSum+1);
                        nOverFlow=false;
                    }
                    
                }else {
                    result.append(nSum);
                }
            }
            else {//nSum最大为18
                if(nOverFlow==true){  //低位上一次有进位
                    result.append(nSum-10+1);
                    //nOverFlow=true;  //本次还有进位，由于本来就是true，无需修改
                }else { 
                    result.append(nSum-10);
                    nOverFlow=true;  //本次有进位
                }   
            }
        }
        
        if(nOverFlow==true){ //最后还有进位，最高位直接加1
            result.append(1);
        }

        return result.reverse().toString();
    }
    
    public static void main(String[] args) {
        
        String str = bigAdd("100000000000009","900000000000001");
                         
        System.out.println("100000000000000");
        System.out.println(str);
    } 
}

运行结果：

100000000000000
1000000000000010
成功构建 (总时间: 0 秒)

算法也许不是最优的，但是最起码让人能轻松看的懂。