java在命令行输入两个长度超过20位的十进制正整数，请你分别用数组保存这两个大数，并输出这两个数的和

### 回答1：
可以回答这个问题。以下是Java代码实现：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String num1 = sc.next();
        String num2 = sc.next();
        int len1 = num1.length();
        int len2 = num2.length();
        int[] arr1 = new int[len1];
        int[] arr2 = new int[len2];
        int[] res = new int[Math.max(len1, len2) + 1];
        for (int i = 0; i < len1; i++) {
            arr1[i] = num1.charAt(len1 - i - 1) - '0';
        }
        for (int i = 0; i < len2; i++) {
            arr2[i] = num2.charAt(len2 - i - 1) - '0';
        }
        int carry = 0;
        int idx = 0;
        while (idx < len1 || idx < len2 || carry > 0) {
            int sum = carry;
            if (idx < len1) {
                sum += arr1[idx];
            }
            if (idx < len2) {
                sum += arr2[idx];
            }
            res[idx] = sum % 10;
            carry = sum / 10;
            idx++;
        }
        StringBuilder sb = new StringBuilder();
        for (int i = idx - 1; i >= 0; i--) {
            sb.append(res[i]);
        }
        System.out.println(sb.toString());
    }
}

代码解释：

1. 首先使用Scanner类从命令行读取两个大数；
2. 分别计算两个大数的长度，创建两个数组用于保存这两个大数；
3. 将每个大数中的每一位数字依次保存到数组中；
4. 定义一个长度为 Math.max(len1, len2) + 1 的数组用于保存相加后的结果；
5. 使用 while 循环依次将两个数组中的每一位数字相加，并记录进位 carry；
6. 在 while 循环结束后，使用 StringBuilder 将数组中的数字拼接成字符串，并输出。

请注意：这段代码仅仅是实现一个加法器，并没有对输入的数据做任何的校验，比如判断输入是否是十进制正整数，也没有考虑大数相加的进位问题，所以仅仅适用于学习和研究使用，实际应用时需要做更多的处理。

### 回答2：
要在命令行输入两个长度超过20位的十进制正整数，可以使用以下代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入第一个大数：");
        String num1 = scanner.next();
        
        System.out.print("请输入第二个大数：");
        String num2 = scanner.next();
        
        int[] array1 = new int[num1.length()];
        for (int i = 0; i < num1.length(); i++) {
            array1[i] = Character.getNumericValue(num1.charAt(i));
        }
        
        int[] array2 = new int[num2.length()];
        for (int i = 0; i < num2.length(); i++) {
            array2[i] = Character.getNumericValue(num2.charAt(i));
        }
        
        int maxLength = Math.max(array1.length, array2.length);
        int[] result = new int[maxLength + 1];
        int carry = 0;
        
        for (int i = 0; i < maxLength; i++) {
            int sum = carry;
            if (i < array1.length) {
                sum += array1[array1.length - 1 - i];
            }
            if (i < array2.length) {
                sum += array2[array2.length - 1 - i];
            }
            
            result[maxLength - i] = sum % 10;
            carry = sum / 10;
        }
        
        result[0] = carry;
        
        StringBuilder sum = new StringBuilder();
        for (int i = 0; i < result.length; i++) {
            sum.append(result[i]);
        }
        
        System.out.println("两个大数的和为：" + sum.toString());
    }
}

以上代码会先分别输入两个大数，然后将两个大数保存在数组中。接着，创建一个长度比两个大数中较长的那个大1的数组来保存计算结果。使用一个循环，从最低位开始逐位相加，并考虑进位。最后，将计算结果转换为字符串并输出。

### 回答3：
要解决这个问题，我们可以先将这两个超过20位的十进制正整数保存在两个数组中，然后逐位相加。由于整数可能很大，我们需要使用数组来保存每一位的值。

首先，我们可以定义两个数组来保存这两个数值的每一位。假设数组`num1`用来保存第一个数值，数组`num2`用来保存第二个数值。由于我们需要保存每一位的值，所以数组的长度需要设置为`Math.max(num1.length, num2.length) + 1`，这样可以确保足够的空间来保存进位的值。

接下来，我们需要遍历这两个数组，从个位开始相加，同时将进位的值也加上。需要注意的是，如果某一位上的数值为空，则默认为0。我们可以使用一个变量`carry`来保存进位的值，并在每一位相加的过程中更新它。

最后，我们可以创建一个`StringBuilder`来保存计算得到的结果，并从数组的高位开始逐位将数值追加到`StringBuilder`中。最后，我们可以将`StringBuilder`转换成字符串，并输出结果。

以下是使用Java代码实现以上算法的示例：

import java.util.Arrays;

public class AddTwoLargeNumbers {
    public static void main(String[] args) {
        String number1 = "12345678901234567890";
        String number2 = "98765432109876543210";

        char[] num1 = number1.toCharArray();
        char[] num2 = number2.toCharArray();

        int maxLength = Math.max(num1.length, num2.length) + 1;
        int[] result = new int[maxLength];

        int carry = 0;
        for (int i = 0; i < maxLength; i++) {
            int digit1 = (i < num1.length) ? num1[num1.length - 1 - i] - '0' : 0;
            int digit2 = (i < num2.length) ? num2[num2.length - 1 - i] - '0' : 0;

            int sum = digit1 + digit2 + carry;
            result[maxLength - 1 - i] = sum % 10;
            carry = sum / 10;
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < maxLength; i++) {
            if (i == 0 && result[i] == 0) {
                continue;
            }
            sb.append(result[i]);
        }

        System.out.println(sb.toString());
    }
}

以上代码运行的结果将会是：111111111111111111100。这是两个超过20位的数值12345678901234567890和98765432109876543210的和。