Question

我正在添加两个非常大的整数，最多125个数字，而不使用Integer类或BigInteger类，只使用java的Stack实用程序。它只是简单地将两个大整数加载到一个堆栈中，然后比较每个pop()。

我最初有一种方法可以从他们自己的JTextArea.getText()

加载堆栈A和B.

 public Stack<Integer> loadStack(String numA)
    {
        Scanner scan = new Scanner(numA);
        Stack<Integer> stack = new Stack<Integer>();
        while (scan.hasNext())
        {
            stack.push(scan.nextInt());
        }
        //System.out.println(stack.toString());
        return stack;
    }

然后我显示结果堆栈的方法称为resTF.setText(num.addStacks(stackA, stackB).toString());，其中resTF是结果的另一个JTextArea。

我添加的方法需要两个Stack<Integer>

。

public Stack<Integer> addStacks(Stack<Integer> stackA, Stack<Integer> stackB)
    { 
        Stack<Integer> resultStack = new Stack<Integer>();

        while(!stackA.empty() && !stackB.empty())
        {
            try
            {   
                int carry = 0;
                //get the digits to add
                int tokenA = stackA.pop();
                int tokenB = stackB.pop();

                //add them and mod 10
                int result = tokenA + tokenB + carry;
                int resultDigit = result % 10;

                //push the result on to the new stack
                resultStack.push(resultDigit);

                //the updated carry
                carry = result / 10;
                if (carry > 0)
                {
                    resultStack.push(carry);
                }
            }
            catch(ArithmeticException e)
            {
                e.printStackTrace();
            }
        }
        System.out.println(resultStack.toString());
        return resultStack;
    }

1：当我想到所需的输出为[6, 66]时，我的堆栈在添加555和111时会给我输出[6,6,6]？为什么是这样？因为它被读入的方式？我相信我可能会在补充中搞砸了。

2：当我输入非常大的数字，例如100000000000000000000000000000000000000和200000000000000000000000000000000000000时，我知道我的loadStacks方法会导致问题，特别是扫描它。我失踪了？

Exception in thread "AWT-EventQueue-0" java.util.InputMismatchException: For input string: "100000000000000000000000000000000000000"
    at java.util.Scanner.nextInt(Scanner.java:2123)
    at java.util.Scanner.nextInt(Scanner.java:2076)
    at GUI.BigNumber.loadStack(BigNumber.java:19)

编辑1 *****

public void checkJagged(Stack<Integer> stackA, Stack<Integer> stackB)
    {
        int stackSizeA = stackA.size();
        int stackSizeB = stackB.size();

        if (stackA.size() < stackB.size())
        {
            for (int i = 0; i < stackSizeB; ++i)
            {
                if (stackA.elementAt(i) == null)
                {
                    stackA.push(0);
                }
            }
        }
        if (stackA.size() > stackB.size())
        {
            for (int i = 0; i < stackSizeA; ++i)
            {
                if (stackB.elementAt(i) == null)
                {
                    stackB.push(0);
                }
            }
        }
    }

Answer 1

输入处理导致所述问题的一部分 - 扫描仪将整个数字读作一个值。做点什么

for (int i = 0; i < numA.length(); i++) {
  stack.push(Integer.parseInt(numA.substring(i, i + 1));
}

另一个问题是你在循环中推进进位。对于具有固定解析器的666 + 666，这将导致1 2 1 2 1 2。它足以在循环中添加进位，并且仅在循环后推送最终进位值。另外，在循环之前将其设置为0，因此实际添加了前一个进位（相反用0覆盖）。

此外，您需要考虑堆栈大小不同的情况。最简单的方法是在一个堆栈不为空时继续运行，并将耗尽的堆栈视为包含零。

Answer 2

我认为您的问题是您希望nextInt()只返回一位数，但它会返回所有连续数字。

您需要将文本框内容用作String并处理字符。

 public Stack<Integer> loadStack(String numA)
 {
     if(numA == null) throw new IllegalArgumentException("...");
     char[] chars = numA.toCharArray();
     Stack<Integer> stack = new Stack<>();
     for (char c : chars) {
        if (Character.isDigit(c))
            stack.push((c - '1') < 9 ? (c - '1' + 1) : 0);
     }
     return stack;
 }

数学

2 个答案: