不能使用任何内置的biginteger库或直接将输入转换为整数。
请注意，您要添加两个整数，每个整数最多5100位。这不是最大值，而是最大位数。
一 int （您的 sum 变量）不能保存这样的值。 BigInteger 可以，但你不能用。
所以，像在纸上一样加上数字：加上最后一个数字，写下和的下一个数字作为结果的最后一个数字，如果需要，再加上一个。重复倒数第二位、倒数第三位等直到完成。
由于总和将至少是最长输入值的位数，并且可能更长，因此您应该分配一个 char[] 最长输入长度加1。完成后，使用 String(char[] value, int offset, int count) ，根据需要偏移0或1。

这个问题的目的是把数字以字符串形式加起来。不应尝试将字符串转换为整数。描述说，这些数字的长度可能高达5100位。所以数字太大了，不能存储在整数和双精度中。例如，在以下行中：

double multiplier = Math.pow(10, num1.length() - 1);

您正在尝试将10^5100存储在 double . 在ieee754二进制浮点标准中 double 你能给我一个商店号码吗 ±4.94065645841246544e-324 至 ±1.79769313486231570e+308 . 所以你的号码不合适。反而会变成 Infinity . 即使它适合 double 这将是不准确的，你会遇到一些错误，在你的后续计算。
因为问题指定不使用biginteger或类似的库，所以您应该自己尝试实现字符串加法。
这很简单，只要实现在纸上添加两个数字时所遵循的精确算法即可。

下面是添加两个字符串而不使用 BigInteger 使用char数组作为中间容器。关键是为什么 double @tempux answer上解释了不能使用。这里的逻辑类似于在纸上加两个数字。

public String addStrings(String num1, String num2) {
    int carry = 0;
    int m = num1.length(), n = num2.length();
    int len = m < n ? n : m;
    char[] res = new char[len + 1]; // length is maxLen + 1 incase of carry in adding most significant digits
    for(int i = 0; i <= len ; i++) {
        int a = i < m ? (num1.charAt(m - i - 1) - '0') : 0;
        int b = i < n ? (num2.charAt(n - i - 1) - '0') : 0;
        res[len - i] = (char)((a + b + carry) % 10 + '0');
        carry = (a + b + carry) / 10;
    }
    return res[0] == '0' ? new String(res, 1, len) : new String(res, 0, len + 1);
}

这个片段相对较小且精确，因为这里我没有使用immutable String 这是复杂的/混乱的，并且产生更大的代码。还有一个直觉是——没有办法获得比这更大的产出 max(num1_length, num2_length) + 1 这使得实现变得简单。

你必须像写在纸上一样写加法
不能使用biginteger和字符串长度5100，因此不能使用int或long进行加法。你必须像我们在纸上做的那样使用简单的加法。

class AddString
{
public static void main (String[] args) throws java.lang.Exception
{
    String s1 = "98799932345";
    String s2 = "99998783456";
    //long n1 = Long.parseLong(s1);
    //long n2 = Long.parseLong(s2);
    System.out.println(addStrings(s1,s2));
    //System.out.println(n1+n2);
}
public static String addStrings(String num1, String num2) {
    StringBuilder ans = new StringBuilder("");
    int n = num1.length();
    int m = num2.length();
    int carry = 0,sum;
    int i, j;
    for(i = n-1,j=m-1; i>=0&&j>=0;i--,j--){
        int a = Integer.parseInt(""+num1.charAt(i));
        int b = Integer.parseInt(""+num2.charAt(j));
        //System.out.println(a+" "+b);
        sum = carry + a + b;
        ans.append(""+(sum%10));
        carry = sum/10;
    }
    if(i>=0){
        for(;i>=0;i--){
            int a = Integer.parseInt(""+num1.charAt(i));
            sum = carry + a;
            ans.append(""+(sum%10));
            carry = sum/10;
        }
    }
    if(j>=0){
        for(;j>=0;j--){
            int a = Integer.parseInt(""+num2.charAt(j));
            sum = carry + a;
            ans.append(""+(sum%10));
            carry = sum/10;
        }
    }
    if(carry!=0)ans.append(""+carry);
    return ans.reverse().toString();
}   
}

您可以运行上面的代码并看到它在所有情况下都能工作，这可以用更简洁的方式编写，但这对您来说很难理解。
希望有帮助！

以前的解决方案有多余的代码。这就是你所需要的。

class ShortStringSolution {
    static String add(String num1Str, String num2Str) {
        return Long.toString(convert(num1Str) + convert(num2Str));
    }

    static long convert(String numStr) {
        long num = 0;
        for(int i = 0; i < numStr.length(); i++) {
            num = num * 10 + (numStr.charAt(i) - '0');
        }
        return num;
    }
}

class LongStringSolution {

    static String add(String numStr1, String numStr2) {
        StringBuilder result = new StringBuilder();
        int i = numStr1.length() - 1, j = numStr2.length() - 1, carry = 0;
        while(i >= 0 || j >= 0) {
            if(i >= 0) {
                carry += numStr1.charAt(i--) - '0';
            }
            if(j >= 0) {
                carry += numStr2.charAt(j--) - '0';
            }
            if(carry > 9) {
                result.append(carry - 10);
                carry = 1;
            } else {
                result.append(carry);
                carry = 0;
            }
        }
        if(carry > 0) {
            result.append(carry);
        }
        return result.reverse().toString();
    }
}

public class Solution {

    static String add(String numStr1, String numStr2) {
        if(numStr1.length() < 19 && numStr2.length() < 19) {
            return ShortStringSolution.add(numStr1, numStr2);
        }
        return LongStringSolution.add(numStr1, numStr2);
    }
}

您可以使用独立于integer或biginteger方法的方法

public String addStrings(String num1, String num2) {
    int l1 = num1.length();
    int l2 = num2.length();
    if(l1==0){
        return num2;
    }
    if(l2==0){
        return num1;
    }
    StringBuffer sb = new StringBuffer();
    int minLen = Math.min(l1, l2);
    int carry = 0;
    for(int i=0;i<minLen;i++){
        int ind = l1-i-1;
        int c1 = num1.charAt(ind)-48;
        ind = l2-i-1;
        int c2 = num2.charAt(ind)-48;
        int add = c1+c2+carry;
        carry = add/10;
        add = add%10;
        sb.append(add);
    }

    String longer = null;
    if(l1<l2){
        longer = num2;
    }
    else if(l1>l2){
        longer = num1;
    }
    if(longer!=null){
        int l = longer.length();
        for(int i=minLen;i<l;i++){
            int c1 = longer.charAt(l-i-1)-48;
            int add = c1+carry;
            carry = add/10;
            add = add%10;
            sb.append(add);
        }
    }
    return sb.reverse().toString();
}

为了理解这个问题
方法的名称是addition
您正试图执行幂运算，但结果存储在名为乘法的变量中。。。
代码不起作用的原因不止一个。。。
你需要做一些像

Integer.parseInt(string)

为了把字符串解析成整数
这是官方文件