Java PEMDAS计算器上的奇数返回

似乎该计算器适用于所有其他情况，但以下情况除外：

（2*3^4）

它不返回162，而是返回0.0

我确定错误一定来自方法

公共静态双精度操作

，因为默认的return语句是0.0

代码如下：

import java.util.Iterator;

import java.util.NoSuchElementException;

public class StackC<Item> implements Stack<Item> {

private Item[] a;         // array of items
private int N;            // number of elements on stack

public StackC() {
    a = (Item[]) new Object[2];
}

public boolean isEmpty() {
    return N == 0;
}

public int size() {
    return N;
}

private void resize(int capacity) {
    assert capacity >= N;
    Item[] temp = (Item[]) new Object[capacity];
    for (int i = 0; i < N; i++) {
        temp[i] = a[i];
    }
    a = temp;
}

public void push(Item item) {
    if (N == a.length) resize(2*a.length);    // double size of array if necessary
    a[N++] = item;                            // add item
}

public Item pop() {
    if (isEmpty()) 
        throw new NoSuchElementException("Stack underflow");
    Item item = a[N-1];
    a[N-1] = null;                              // to avoid loitering
    N--;
    // shrink size of array if necessary
    if (N > 0 && N == a.length/4) 
        resize(a.length/2);
    return item;
}

public Item peek() {
    if (isEmpty()) 
        throw new NoSuchElementException("Stack underflow");
    return a[N-1];
}

public Iterator<Item> iterator() {
    return new ReverseArrayIterator();
}

private class ReverseArrayIterator implements Iterator<Item> {
    private int i;

    public ReverseArrayIterator() {
        i = N;
    }

    public boolean hasNext() {
        return i > 0;
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }

    public Item next() {
        if (!hasNext()) throw new NoSuchElementException();
        return a[--i];
    }
}

//---------------------------------------------------------------------

public static void main(String[] args) {
    StackC<String> Operator = new StackC<String>();
    StackC<Double> Values = new StackC<Double>();

    while (!StdIn.isEmpty()) {

        String token = StdIn.readString();

        try { 
            Double x = Double.parseDouble(token);
            Values.push(x);
        }
        catch(NumberFormatException nFE) {

        }

        if (token.equals("(")) 
            Operator.push(token); 

        if (token.equals(")")) 
        {
            if (Operator.peek() != "(")
            {
                String type = Operator.pop();
                double b = Values.pop();
                double a = Values.pop();

                Values.push(operation(type,a,b));
            }
            Operator.pop();
        }

        if(token.equals("*") || token.equals("+") || token.equals("/") || token.equals("-") || token.equals("^") )
        {
            if(!Operator.isEmpty())
            {
                String prev = Operator.peek();

                int x = comparePrecedence(token, Operator.peek()); // You need to compare precedence first

                if(x == -1 || x == 0)
                {

                    String type = Operator.pop();
                    double b = Values.pop();
                    double a = Values.pop();

                    Values.push(operation(type,a,b));
                }

            } 
            Operator.push(token);

        } 
    }

    while(!Operator.isEmpty())
    {

        String prev = Operator.peek();

        String type = Operator.pop();
        double b = Values.pop();
        double a = Values.pop();

        Values.push(operation(type,a,b));

    }
    System.out.println(Values.pop());
}

public static double operation(String operator, double a, double b) {  
    if (operator.equals("+"))  
        return a + b;  
    else if (operator.equals("-"))  
        return a - b;  
    else if (operator.equals("*"))  
        return a * b;
    else if (operator.equals("/"))  
        return a / b;
    else if (operator.equals("^"))
        return Math.pow(a,b);
    return 0.0;
} 

public static int comparePrecedence(String x, String y)
{
    int val1 = 0;
    int val2 = 0; 

    if(x.equals("-"))
        val1 = 0;
    if(y.equals("-"))
        val2 = 0;

    if(x.equals("+"))
        val1 = 1;
    if(y.equals("+"))
        val2 = 1;

    if(x.equals("/"))
        val1 = 2;
    if(y.equals("/"))
        val2 = 2;

    if(x.equals("*"))
        val1 = 3;
    if(y.equals("*"))
        val2 = 3;

    if(x.equals("^"))
        val1 = 4;
    if(y.equals("^"))
        val2 = 4;

    if(val1 > val2)
        return 1;
    else if(val2 > val1)
        return -1;
    else 
        return 0;
}

}

import java.util.Iterator；
导入java.util.NoSuchElementException；
公共类StackC实现Stack{
私有项[]a；//项数组
private int N；//堆栈上的元素数
公共图书馆c（{
a=（项目[]）新对象[2]；
}
公共布尔值为空（）{
返回N==0；
}
公共整数大小（）{
返回N；
}
专用空间大小调整（整数容量）{
断言容量>=N；
项目[]临时=（项目[]）新对象[容量]；
对于（int i=0；i0&&N==a.length/4）
调整大小（a.长度/2）；
退货项目；
}
公共项目peek（）{
if（isEmpty（））
抛出新的NoTouchElementException（“堆栈下溢”）；
返回[N-1]；
}
公共迭代器迭代器（）{
返回新的ReverseArrayIterator（）；
}
私有类ReverseAryIterator实现迭代器{
私人互联网i；
公共ReverseArrayIterator（）{
i=N；
}
公共布尔hasNext（）{
返回i>0；
}
公共空间删除（）{
抛出新的UnsupportedOperationException（）；
}
公共项目下一步（）{
如果（！hasNext（））抛出新的NoSuchElementException（）；
返回一个[--i]；
}
}
//---------------------------------------------------------------------
公共静态void main（字符串[]args）{
StackC运算符=新的StackC（）；
StackC值=新的StackC（）；
而（！StdIn.isEmpty（））{
字符串标记=StdIn.readString（）；
试试{
Double x=Double.parseDouble（令牌）；
推送（x）；
}
捕获（NumberFormatException nFE）{
}
if（标记为等于（“”）
操作员推送（令牌）；
if（标记为等于（“）”）
{
if（Operator.peek（）！=“（”）
{
字符串类型=Operator.pop（）；
double b=Values.pop（）；
double a=Values.pop（）；
push（操作（类型，a，b））；
}
操作符pop（）；
}
if（token.equals（“*”）| token.equals（“+”）| token.equals（“/”）| token.equals（“-”）| token.equals（“^”））
{
如果（！Operator.isEmpty（））
{
字符串prev=Operator.peek（）；
int x=comparePresence（标记，Operator.peek（））；//您需要先比较优先级
如果（x==1 | | x==0）
{
字符串类型=Operator.pop（）；
double b=Values.pop（）；
double a=Values.pop（）；
push（操作（类型，a，b））；
}
} 
操作员推送（令牌）；
} 
}
而（！Operator.isEmpty（））
{
字符串prev=Operator.peek（）；
字符串类型=Operator.pop（）；
double b=Values.pop（）；
double a=Values.pop（）；
push（操作（类型，a，b））；
}
System.out.println（Values.pop（））；
}
公共静态双操作（字符串运算符，双a，双b）{
if（运算符等于（“+”）
返回a+b；
else if（运算符等于（“-”）
返回a-b；
else if（运算符等于（“*”）
返回a*b；
else if（运算符等于（“/”）
返回a/b；
else if（运算符等于（“^”））
返回Math.pow（a，b）；
返回0.0；
} 
公共静态int比较接收（字符串x、字符串y）
{
int val1=0；
int val2=0；
如果（x等于（“-”）
val1=0；
如果（y等于（“-”）
val2=0；
如果（x等于（“+”）
val1=1；
如果（y等于（“+”）
val2=1；
如果（x等于（“/”）
val1=2；
如果（y等于（“/”）
val2=2；
如果（x等于（“*”）
val1=3；
如果（y等于（“*”）
val2=3；
如果（x等于（“^”））
val1=4；
如果（y等于（“^”））
val2=4；
如果（val1>val2）
返回1；
else if（val2>val1）
返回-1；
其他的
返回0；
}
}

虚线以上的所有内容都是通过教授给出的，这不是代码的问题

---

StdIn

只是一种读取输入的方法。

我建议您调试代码，然后一步一步地查看发生了什么。确保

运算符

是您认为的