java中两个超大数相加以及BigInteger介绍

 public  static  String add(String add1,String add2){
         System.out.println(add1);
         System.out.println(add2);
         String addNum1 = (new StringBuffer(add1)).reverse().toString();
         String addNum2 = (new StringBuffer(add2)).reverse().toString();
         int length1 = addNum1.length();
         int length2 = addNum2.length();
         //tempAdd1的位数多余tempAdd2
         String tempAdd1 = addNum1 ;
         String tempAdd2 = addNum2;
         if(length1
             tempAdd1 = addNum2;
             tempAdd2 = addNum1;
         }
         StringBuffer sb = new StringBuffer();
         int jinWei = 0;
         int tailNum = 0;
         for(int i=0;i
             int  temp1 = Character.digit(tempAdd2.charAt(i),10);
             int temp2 = Character.digit(tempAdd1.charAt(i),10);
             int total = temp1+ temp2+jinWei;
             if(total>9){
                 jinWei = 1;
                 tailNum = Character.digit(String.valueOf(total).charAt(1), 10);
             }else{
                 jinWei = 0;
                 tailNum = total;
             }
             sb.append(tailNum);
         }
         for(int i=tempAdd2.length();i
             int  temp = Character.digit(tempAdd1.charAt(i),10);
             int  total = temp + jinWei;
             if(total>9){
                 jinWei = 1;
                 tailNum = 0;
                 sb.append(tailNum);
             }else{
                 sb.append(total);
                 System.out.println(i+1);
                 sb.append(tempAdd1.substring(i+1));
                 break;
             }
         }
         if(jinWei>0){
             sb.append(jinWei);
         }
         System.out.println(sb.reverse().toString());
         return null;
     }

算法2： 

 /**
      *
      *@parama加数字符串1
      *@paramb加数字符串2
      *@return结果字符串
      *分析：
      *1、取得两个字符串的长度
      *2、把两个的长度做比较，并得出较长的长度，及较短的长度
      *3、把长度较短的加数字符串，在左面补0，使之与较长的字符串一样长
      *4、从最高位，一个个数的取出来相加，当然首先得转换为整型
      *5、设置进位，如果两个数相加及加上进位大于等于10，并且这不是最左边一个字符相加，相加结果等于
      *    （取出1＋取出2＋进位）－10，并把进位设为1；如果没有大于10，就把进位设为0，如些循环，把
      *    相加的结果以字符串的形式结合起来，就得到最后的结果
      */
     String doAdd(String a, String b)
     {
         String str = "";
         int lenA = a.length();
         int lenB = b.length();
         int maxLen = (lenA > lenB) ? lenA : lenB;
         int minLen = (lenA < lenB) ? lenA : lenB;
         String strTmp = "";
         for (int i = maxLen - minLen; i > 0; i--)
         {
             strTmp += "0";
         }
         //把长度调整到相同
         if (maxLen == lenA)
         {
             b = strTmp + b;
         }
         else
         {
             a = strTmp + a;
         }
         int JW = 0;//进位
         for (int i = maxLen - 1; i >= 0; i--)
         {
             int tempA = Integer.parseInt(String.valueOf(a.charAt(i)));
             int tempB = Integer.parseInt(String.valueOf(b.charAt(i)));
             int temp;
             if (tempA + tempB + JW >= 10 && i != 0)
             {
                 temp = tempA + tempB + JW - 10;
                 JW = 1;
             }
             else
             {
                 temp = tempA + tempB + JW;
                 JW = 0;
             }
             str = String.valueOf(temp) + str;
         }
         return str;
     }

8种基本数据类型中，long类型所能表示的整数范围是最大的，但还是有限的。另外，基本数据类型中的整数还有一个问题，那就是不是每个数都能够正确的取负数。例如，对int型而言，“-2147483648”取负就不能得到正确的结果，对其他整数类型也有这个问题。 

为了解决这些问题，Java中专门提供了用来进行不限制大小的整数计算的类——java.math.BigInteger。该类可以对任意大小的整数进行操作，不过在进行计算的时候是通过方法调用进行的，而不是使用算术运算符 


BigInteger b1=new BigInteger("11111111111111111111111111");  
BigInteger b2=new BigIntege("22222222222222222222222222");            
System.out.println("加法运算:");  
System.out.println("b1:"+b1);  
System.out.println("b2:"+b2);  
System.out.println("相加结果值");  
System.out.println("相加后的值:"+b1.add(b2));