Java 使用自定义堆栈的括号匹配程序输出中未定义的字符

下面是我的Java程序。这是我的训练。一个实现了特殊类型的字符串解析（带分隔符的字符串）的堆栈结构

此分隔符匹配程序通过一次读取字符串中的字符来工作 时间，并在堆栈上找到开始分隔符时放置它们。当它读到 输入中的结束分隔符，它会从输入的顶部弹出开始分隔符 堆栈并尝试将其与结束分隔符匹配。如果他们不一样 键入一个错误（例如，有一个左括号，但有一个右括号） 发生。此外，如果堆栈上没有与结束分隔符匹配的开始分隔符，或者 如果分隔符未匹配，则会发生错误。未使用的分隔符 查找匹配的，因为它保留在堆栈中的所有字符之后 字符串已被读取

我使用Eclipse。我的输出如下：

Please enter String:
{}
ch0 = {
ch1 = }
chLabel1 = **UNDEFINED CHAR(SQUARE WITH QUESTION MARK INSIDE IT)**
Error at }**

你能解释一下

chLabel

的价值吗

据我所知，运算符“|”（在这里，因为两个操作数都是布尔类型）是“惰性的”，是“| |”运算符的快捷版本。我在用“| |”替换“| |”后测试了该程序-结果相同

public class MyStack {
    private int top=0;
    private int maxSize=0;
    private char[] charArray=null;

    public MyStack(int size){
        maxSize=size;
        top=0;
        charArray=new char[maxSize];
    }

    public void push(char ch){
        charArray[top++]=ch;
    }

    public char pop(){
        return charArray[top--];
    }

    public boolean isEmpty(){
        if(top==0)          
        return true;
        else return false;
    }

    public boolean isFull(){
        if(top==(maxSize-1))            
        return true;
        else return false;
    }
}


class StringParse {
    private String stringForParsing = null;

    public StringParse(String string) {
        this.stringForParsing = string;
    }

    public void parser() {
        char[] chArr = stringForParsing.toCharArray();
        MyStack mySt = new MyStack(chArr.length);

        for (int i = 0; i < chArr.length; i++) {
            char ch = chArr[i];

            switch (ch) {
                case '{':
                case '(':
                case '[':
                    mySt.push(ch);
                    System.out.println("ch" + i + " = " + ch);
                    break;

                case '}':
                case ')':
                case ']':
                    if (mySt.isEmpty())
                        System.out.println("Error at" + ch);
                    else {
                        char chLabel = mySt.pop();
                        System.out.println("ch" + i + " = " + ch);
                        System.out.println("chLabel" + i + " = " + chLabel);

                        if ((chLabel == '{') && (ch == '}') | (chLabel == '(') && (ch == ')') | (chLabel == '[') && (ch == ']'))
                            break;

                        else {
                            System.out.println("Error at " + ch);
                            break;
                        } // end of second else
                    } //end of first else

                default:
                    break;
            } //end of switch
        } //end of parser method
    }
} //end of class


class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System. in ));
        System.out.println("Please enter String:");
        String s = br.readLine();

        StringParse strP = new StringParse(s);
        strP.parser();
    }
}

公共类MyStack{
私有int top=0；
私有int maxSize=0；
private char[]charArray=null；
公共MyStack（整数大小）{
最大尺寸=尺寸；
top=0；
charArray=新字符[maxSize]；
}
公共无效推送（char ch）{
charArray[top++]=ch；
}
公共字符pop（）{
返回字符[top--]；
}
公共布尔值为空（）{
如果（顶部==0）
返回true；
否则返回false；
}
公共布尔值isFull（）{
如果（顶部==（最大尺寸-1））
返回true；
否则返回false；
}
}
类StringParse{
私有字符串stringForParsing=null；
公共字符串解析（字符串）{
this.stringForParsing=string；
}
公共空解析器（）{
char[]chArr=stringForParsing.toCharArray（）；
MyStack mySt=新MyStack（字符长度）；
for（int i=0；i

您的

MyStack

类可能有问题

使用

java.util.Stack

不会给我任何错误，只是一个“

chLabel1={

”

可以按照杜克林的建议，使用

|

而不是

|

来解决}处的

错误：

(chLabel == '{') && (ch == '}') || (chLabel == '(') && (ch == ')') || (chLabel == '[') && (ch == ']')

因此，
MyStack.pop（）
中的代码似乎没有返回有效的
char
。我需要查看您的
MyStack
代码以进一步提供帮助。
有两个问题：


pop
功能出错

考虑执行一次
推送
，然后执行一次
弹出
：

top = 0
push
  insert at position 0
  set top to 1
pop
  get position 1 (not set yet!)
  set top to 0

您需要使用预减量而不是后减量，因此
charArray[top-->
应该是
charArray[--top]

通过此更改，我得到
chLabel1={

重申我在评论中说的话

|
的优先级高于
&&
（与优先级较低的
|
相反）（请参阅）‌​,

因此
a&&b|c&&d
与
a&&b|c&&d
，

与
a&b | c&d
相反，后者将是
（a&b）| |（c&d）

当将
|
更改为
|
时，我在}

处不再出现

错误

我认为在发生流行性感冒的情况下，你应该使用double | |。否则，它将执行二进制或而不是或。这可能是您的问题的根源。您是否为MyStack提供了代码？当我用
java.util.Stack
替换
MyStack
时（因为您没有为
MyStack
提供代码），我没有看到任何这样奇怪的字符，只有一个
{
。
MyStack
中可能有一个bug，它的优先级高于
&
（与优先级较低的
|
相反）（参见），因此
a&&b | c&&d
与
a&（b | c）&&d
相同，而
a&&b | c&&d则是
 && （b） || （c） && d） 
。这是
|
与
|
之间唯一的区别，以及，这在这里没有太大区别。|是按位包含的，而| |是逻辑或。