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

1. public  static  String add(String add1,String add2){  
2.         System.out.println(add1);  
3.         System.out.println(add2);  
4.         String addNum1 = (new StringBuffer(add1)).reverse().toString();  
5.         String addNum2 = (new StringBuffer(add2)).reverse().toString();  
6.         int length1 = addNum1.length();  
7.         int length2 = addNum2.length();  
8.         //tempAdd1的位数多余tempAdd2  
9.         String tempAdd1 = addNum1 ;  
10.         String tempAdd2 = addNum2;  
11.         if(length1<length2){  
12.             tempAdd1 = addNum2;  
13.             tempAdd2 = addNum1;  
14.         }  
15.         StringBuffer sb = new StringBuffer();   
16.         int jinWei = 0;  
17.         int tailNum = 0;  
18.         for(int i=0;i<tempAdd2.length();i++){  
19.             int  temp1 = Character.digit(tempAdd2.charAt(i),10);  
20.             int temp2 = Character.digit(tempAdd1.charAt(i),10);  
21.             int total = temp1+ temp2+jinWei;  
22.             if(total>9){  
23.                 jinWei = 1;  
24.                 tailNum = Character.digit(String.valueOf(total).charAt(1), 10);  
25.             }else{  
26.                 jinWei = 0;  
27.                 tailNum = total;  
28.             }  
29.             sb.append(tailNum);  
30.         }  
31.         for(int i=tempAdd2.length();i<tempAdd1.length();i++){  
32.             int  temp = Character.digit(tempAdd1.charAt(i),10);  
33.             int  total = temp + jinWei;  
34.             if(total>9){  
35.                 jinWei = 1;  
36.                 tailNum = 0;  
37.                 sb.append(tailNum);  
38.             }else{  
39.                 sb.append(total);  
40.                 System.out.println(i+1);  
41.                 sb.append(tempAdd1.substring(i+1));  
42.                 break;  
43.             }  
44.         }  
45.         if(jinWei>0){  
46.             sb.append(jinWei);  
47.         }  
48.         System.out.println(sb.reverse().toString());  
49.         return null;  
50.     }  

算法2： 

Java代码  

1. /** 
2.      * 
3.      *@parama加数字符串1 
4.      *@paramb加数字符串2 
5.      *@return结果字符串 
6.      *分析： 
7.      *1、取得两个字符串的长度 
8.      *2、把两个的长度做比较，并得出较长的长度，及较短的长度 
9.      *3、把长度较短的加数字符串，在左面补0，使之与较长的字符串一样长 
10.      *4、从最高位，一个个数的取出来相加，当然首先得转换为整型 
11.      *5、设置进位，如果两个数相加及加上进位大于等于10，并且这不是最左边一个字符相加，相加结果等于 
12.      *    （取出1＋取出2＋进位）－10，并把进位设为1；如果没有大于10，就把进位设为0，如些循环，把 
13.      *    相加的结果以字符串的形式结合起来，就得到最后的结果 
14.      */  
15.     String doAdd(String a, String b)  
16.     {  
17.         String str = "";  
18.         int lenA = a.length();  
19.         int lenB = b.length();  
20.         int maxLen = (lenA > lenB) ? lenA : lenB;  
21.         int minLen = (lenA < lenB) ? lenA : lenB;  
22.         String strTmp = "";  
23.         for (int i = maxLen - minLen; i > 0; i--)  
24.         {  
25.             strTmp += "0";  
26.         }  
27.         //把长度调整到相同  
28.         if (maxLen == lenA)  
29.         {  
30.             b = strTmp + b;  
31.         }  
32.         else  
33.         {  
34.             a = strTmp + a;  
35.         }  
36.         int JW = 0;//进位  
37.         for (int i = maxLen - 1; i >= 0; i--)  
38.         {  
39.             int tempA = Integer.parseInt(String.valueOf(a.charAt(i)));  
40.             int tempB = Integer.parseInt(String.valueOf(b.charAt(i)));  
41.             int temp;  
42.             if (tempA + tempB + JW >= 10 && i != 0)  
43.             {  
44.                 temp = tempA + tempB + JW - 10;  
45.                 JW = 1;  
46.             }  
47.             else  
48.             {  
49.                 temp = tempA + tempB + JW;  
50.                 JW = 0;  
51.             }  
52.             str = String.valueOf(temp) + str;  
53.         }  
54.         return str;  
55.     }  

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));