大数乘法与大数加法 java实现

原文：https://blog.csdn.net/bitcarmanlee/article/details/51774423

最近碰到大数乘法与大数加法的需求，如果直接用int类型会溢出。于是自己写了个大数乘法与大数加法的代码，就当自己练练手了。

1.大数加法

大数加法的逻辑相对乘法稍微简单一些。先将输入的两个字符串逆序生成字符数组，然后相同位上的字符相加保存在一个结果数组中。最后遍历结果数组，如果当前位的结果大于或等于10，则先将当前位的数值除以10加入下一位，当前位的值为取10的模。

看代码如下：

package leilei.bit.edu.bigNum;

public class AllNumAdd {

    public static String add(String s1,String s2) {
        //先将输入的两个串逆序生成字符数组
        char[] a = new StringBuilder(s1).reverse().toString().toCharArray();
        char[] b = new StringBuilder(s2).reverse().toString().toCharArray();

        //结果数组的最大长度为两个数组中长度较大的那个再加1
        int lenA = a.length;
        int lenB = b.length;
        int maxlen = lenA > lenB ? lenA : lenB;
        int[] result = new int[maxlen+1];

        //如果当前位超过了最大的长度，补0即可
        for(int i=0; i1; i++) {
            int aint = i < lenA ? (a[i] - '0') : 0;
            int bint = i < lenB ? (b[i] - '0') : 0;
            result[i] = aint + bint;
        }

        //遍历结果数组，大于10进位，当前位取10的模
        for(int i=0; iif(result[i] >= 10) {
                result[i+1] += result[i] /10;
                result[i] %= 10;
            }
        }

        StringBuilder sb = new StringBuilder();
        if (result[maxlen] != 0) {
            sb.append(result[maxlen]);
        }

        for(int i=maxlen-1; i>=0; i--) {
            sb.append(result[i]);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String s1 = "1234567890";
        String s2 = "32110";
        String ret = add(s1,s2);
        System.out.println("ret is: " + ret);
    }

}

     
     
     
     

      
      
      
      
1
      
      
      
      
2
      
      
      
      
3
      
      
      
      
4
      
      
      
      
5
      
      
      
      
6
      
      
      
      
7
      
      
      
      
8
      
      
      
      
9
      
      
      
      
10
      
      
      
      
11
      
      
      
      
12
      
      
      
      
13
      
      
      
      
14
      
      
      
      
15
      
      
      
      
16
      
      
      
      
17
      
      
      
      
18
      
      
      
      
19
      
      
      
      
20
      
      
      
      
21
      
      
      
      
22
      
      
      
      
23
      
      
      
      
24
      
      
      
      
25
      
      
      
      
26
      
      
      
      
27
      
      
      
      
28
      
      
      
      
29
      
      
      
      
30
      
      
      
      
31
      
      
      
      
32
      
      
      
      
33
      
      
      
      
34
      
      
      
      
35
      
      
      
      
36
      
      
      
      
37
      
      
      
      
38
      
      
      
      
39
      
      
      
      
40
      
      
      
      
41
      
      
      
      
42
      
      
      
      
43
      
      
      
      
44
      
      
      
      
45
      
      
      
      
46
      
      
      
      
47
      
      
      
      
48
      
      
      
      
49
      
      
      
      
50
     
     
     
     

代码运行结果为:

ret is: 1234600000
     
     
     
     

      
      
      
      
1
     
     
     
     

2.大数乘法

大数乘法的逻辑相对加法稍微复杂一些。首先也先将输入的两个字符串逆序生成字符数组，假设两个字符串分别为A、B，则保存结果的数组长度为len(A)+len(B)。A的第i位于B的第j位的乘积，保存在结果数组的第i+j位上。将所有的计算结果计算完毕以后，再遍历结果数组进行进位处理。

package leilei.bit.edu.bigNum;

public class Multiply {

    public static String multiply(String s1,String s2) {
        //符号问题，如果两字符串异号，最后的结果为'-'
        char signA = s1.charAt(0);
        char signB = s2.charAt(0);
        char sign = '+';
        if(signA == '-' && signB != '-') {
            s1 = s1.substring(1);
            sign = signA;
        }
        if(signB == '-' && signA != '-') {
            s2 = s2.substring(1);
            sign = signB;
        }

        char[] a = new StringBuilder(s1).reverse().toString().toCharArray();
        char[] b = new StringBuilder(s2).reverse().toString().toCharArray();
        int lenA = a.length;
        int lenB = b.length;

        //结果数组
        int maxLen = lenA + lenB;
        int[] ret = new int[maxLen];

        //每一位分别相乘
        for(int i=0; ifor(int j=0; j'0') * (b[j] - '0');
            }
        }

        //大于10，进位
        for(int i=0; iif(ret[i] >= 10) {
                ret[i+1] += ret[i] /10;
                ret[i] %= 10;
            }
        }

        //如果第一位为0，不输出
        StringBuilder sb = new StringBuilder();
        if(ret[ret.length-1] != 0) {
            sb.append(ret[ret.length-1]);
        }
        for(int i=ret.length-2; i>=0; i--) {
            sb.append(ret[i]);
        }
        if (sign == '-') { //如果是异号，在结果中插入'-'
            sb.insert(0, sign);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String s1 = "-999";
        String s2 = "100";
        String result = multiply(s1, s2);
        System.out.println("result is: " + result);
    }

}

     
     
     
     

      
      
      
      
1
      
      
      
      
2
      
      
      
      
3
      
      
      
      
4
      
      
      
      
5
      
      
      
      
6
      
      
      
      
7
      
      
      
      
8
      
      
      
      
9
      
      
      
      
10
      
      
      
      
11
      
      
      
      
12
      
      
      
      
13
      
      
      
      
14
      
      
      
      
15
      
      
      
      
16
      
      
      
      
17
      
      
      
      
18
      
      
      
      
19
      
      
      
      
20
      
      
      
      
21
      
      
      
      
22
      
      
      
      
23
      
      
      
      
24
      
      
      
      
25
      
      
      
      
26
      
      
      
      
27
      
      
      
      
28
      
      
      
      
29
      
      
      
      
30
      
      
      
      
31
      
      
      
      
32
      
      
      
      
33
      
      
      
      
34
      
      
      
      
35
      
      
      
      
36
      
      
      
      
37
      
      
      
      
38
      
      
      
      
39
      
      
      
      
40
      
      
      
      
41
      
      
      
      
42
      
      
      
      
43
      
      
      
      
44
      
      
      
      
45
      
      
      
      
46
      
      
      
      
47
      
      
      
      
48
      
      
      
      
49
      
      
      
      
50
      
      
      
      
51
      
      
      
      
52
      
      
      
      
53
      
      
      
      
54
      
      
      
      
55
      
      
      
      
56
      
      
      
      
57
      
      
      
      
58
      
      
      
      
59
      
      
      
      
60
      
      
      
      
61
      
      
      
      
62
      
      
      
      
63
      
      
      
      
64
      
      
      
      
65