Java 每次进行计算时，如何打印RPN计算器的堆栈？

我希望这个问题很容易回答，但是我在制作RPN计算器时遇到了一个问题，我希望程序在每次进行计算时打印出“答案”，而不是必须指定文件结尾（Ctrl+Z）才能看到计算的答案。对于上下文，以下是我正在使用的代码：

import java.util.Scanner;


public class McIntyreJLab3 {
    
    public static void main (String args[]) {
        processInput rpninput = new processInput();
    }
}//McIntyreJLab1

class processInput {

    processInput() {
        
        double doubleval = 0;
        int charval = 0;
        String ident = "";
        Stack stack = new Stack();
        
        Scanner in = new Scanner (System.in);
        
        System.out.println("Please enter your input into the command line, then once you have submitted your input, please type Ctrl + Z signify you have finished your input.");
        
        while (in.hasNext()) {
            if (in.hasNextDouble()) {
                doubleval = in.nextDouble();
                System.out.println(doubleval + ": Double");
                stack.push(doubleval);
            } else {//if there is a double at the current placeholder on the input
                ident = in.next();
                charval = (int) ident.charAt(0);
                if(charval == 42|| charval == 43 || charval == 45 || charval == 47) {
                    System.out.println(ident + ": Operator");
                    double v1 = stack.pop();
                    double v2 = stack.pop();
                    switch (charval) {
                    
                    case 42:
                        v2 = v2 * v1;
                        stack.push(v2);
                        break;
                    case 43:
                        v2 = v2 + v1;
                        stack.push(v2);
                        break;
                    case 45:
                        v2 = v2 - v1;
                        stack.push(v2);
                        break;
                    case 47:
                        v2 = v2 / v1;
                        stack.push(v2);
                        break;
                    default: 
                        System.out.println("That is not an acceptable operator");
                        break;
                    }
                } else { //checking for operators
                    System.out.println(ident + ": Identifier");
                }//since no operator was found, it is an identifier
            }//else statement for operators
            
        }//loop for taking in the input and categorizing it into: identifier, operator, or double.
        
        System.out.println("End of Line Reached");
        double result = stack.pop();
        
        if (!stack.isEmpty()) {
            System.out.println("Too many operators or doubles");
            System.exit(0);
        } else {
            System.out.println(result);
        }
       
    }//processInput method
}//processInput class

class Stack {
    
    private int stack_capacity = 100;
    private int tos = -1;
    private double[] my_stack = new double[stack_capacity];
    
    public void push(double item_to_push) {
        
        if (tos + 1 >= stack_capacity) {
            System.out.println("Exceeded Capacity");
            System.exit(0);
        }//checking if the stack will overflow
        tos++;
        my_stack[tos] = item_to_push;
    }//pushing doubles into the stack
    
    public double pop() throws NullPointerException {
        if (tos < 0) {
            System.out.println("Stack is empty");
            System.exit(0);
        }//if the stack is empty
        double v = my_stack[tos];
        tos--;
        return v;
    }//pop a value
    
    public boolean isEmpty(){
          return tos == -1;
    }
    
    
}//Stack

import java.util.Scanner；
公共类McIntyreJLab3{
公共静态void main（字符串参数[]）{
processInput rpninput=新的processInput（）；
}
}//McIntyreJLab1
类processInput{
processInput（）{
double-doubleval=0；
int charval=0；
字符串标识符=”；
堆栈=新堆栈（）；
扫描仪输入=新扫描仪（系统输入）；
System.out.println（“请在命令行中输入您的输入，然后提交输入后，请键入Ctrl+Z表示您已完成输入。”）；
while（在.hasNext（）中）{
if（in.hasNextDouble（））{
doubleval=in.nextDouble（）；
System.out.println（doubleval+“：Double”）；
堆栈推送（doubleval）；
}else{//如果在输入的当前占位符处有一个双精度
ident=in.next（）；
charval=（int）标识字符（0）；
如果（charval==42 | | charval==43 | | charval==45 | | charval==47）{
系统输出打印项次（标识+“：运算符”）；
double v1=stack.pop（）；
double v2=stack.pop（）；
开关（charval）{
案例42：
v2=v2*v1；
堆栈推送（v2）；
打破
案例43：
v2=v2+v1；
堆栈推送（v2）；
打破
案例45：
v2=v2-v1；
堆栈推送（v2）；
打破
案例47：
v2=v2/v1；
堆栈推送（v2）；
打破
违约：
System.out.println（“这不是一个可接受的操作员”）；
打破
}
}else{//正在检查运算符
System.out.println（ident+“：Identifier”）；
}//由于未找到运算符，因此它是一个标识符
}//操作员的else语句
}//用于接收输入并将其分类为标识符、运算符或双精度的循环。
System.out.println（“到达行尾”）；
double result=stack.pop（）；
如果（！stack.isEmpty（））{
System.out.println（“运算符太多或加倍”）；
系统出口（0）；
}否则{
系统输出打印项次（结果）；
}
}//过程输入法
}//processInput类
类堆栈{
专用int堆栈_容量=100；
私有int tos=-1；
专用双精度[]我的双精度堆栈=新双精度[堆栈容量]；
公共无效推送（双项推送）{
如果（tos+1>=堆栈容量）{
系统输出打印项次（“超出容量”）；
系统出口（0）；
}//检查堆栈是否会溢出
tos++；
my_stack[tos]=要推送的项目；
}//将替身推入堆栈
public double pop（）抛出NullPointerException{
如果（tos<0）{
System.out.println（“堆栈为空”）；
系统出口（0）；
}//如果堆栈为空
双v=我的_堆栈[tos]；
tos--；
返回v；
}//弹出一个值
公共布尔值为空（）{
返回tos==-1；
}
}//堆叠

为了快速总结这段代码目前所做的工作（您也可以自己尝试），它本质上要求值和运算符以反向波兰符号格式执行计算，问题是，为了得到答案，您必须按Ctrl+Z，然后输入以指定文件结尾，该结尾将显示答案，但也会阻止用户输入更多值。假设用户希望继续计算已经输入的内容，我需要做什么才能允许用户继续输入值和运算符？如果有人能帮我，那就太好了