Java 为什么我检查是否有括号等的方法不起作用？

我制作了一个程序，要求用户输入一个等式，比如{x+（y-2）*1}+[a+b]，并检查是否每个括号和括号都闭合。如果我的方法发现它关闭了，它将打印：表达式：{x+（y-2）*1}+[a+b]->是平衡的。我的问题是我的方法似乎每次都默认为不平衡，所以我怀疑这是isBalanced方法中的一个问题。有人能告诉我我的语法是否错误吗？当我读到它时，它似乎流动得很好。 这是我的密码：

import java.util.*;
import java.io.*;
public class BalancedParanthesis {
        static String expressions[];
        static class    MyArrayStack{
            int top = -1;
            char brackets[] = new char[100];
            void push(char x) {
                if(top ==99) {
                    System.out.print("Stack full");
                }
                else {
                    brackets[++top] = x;
                }
                }
            char pop() {
                if(top ==-1) {
                    System.out.println("ERROR:Stack undeflow error");
                    return '\0';
                }
                else {
                    char element = brackets[top];
                    top--;
                    return element; 
                }
            }

            boolean isEmpty() {
                return(top==-1)?true:false;
            }
        }
        static boolean isMatchingPair(char bracketOne,char bracketTwo) {
            if(bracketOne=='('&& bracketTwo ==')') {
                return true;
            }
            else if(bracketOne == '{'&& bracketTwo == '}') {
                return true;
            }
            else if(bracketOne == '['&& bracketTwo ==']') {
                return true;
            }
            else {
                return false;
            }

        }
        static boolean isBalanced(String expression) {
            MyArrayStack st =new MyArrayStack();
            for(int index = 0; index<expression.length();index++) {
                if(expression.charAt(index)=='{'|| expression.charAt(index)=='(' || expression.charAt(index)=='{') {
                    st.push(expression.charAt(index));
                }
                if(expression.charAt(index)=='}'|| expression.charAt(index)==')'||expression.charAt(index)=='}'){
                        if(st.isEmpty()) {
                            return false;
                        }
                }
                else if(!isMatchingPair(st.pop(),expression.charAt(index))) {
                    return false;
                }
            }
            if(st.isEmpty()) {
                return true;
            }
            else {
                return false;
            }
        }
        public static void main(String[] args) {
            System.out.println("Input: ");
            Scanner input = new Scanner(System.in);
            String x = input.next();
            if(isBalanced(x)) {
                System.out.println("\n Expression: " + x + " is balanced");
            }
            else {
                System.out.println("\n Expression: " + x + " is not balanced");
            }
        }

        }

import java.util.*；
导入java.io.*；
公共阶级平衡{
静态字符串表达式[]；
静态类MyArrayStack{
int top=-1；
字符括号[]=新字符[100]；
无效推送（字符x）{
如果（顶部==99）{
系统输出打印（“堆栈已满”）；
}
否则{
括号[++顶部]=x；
}
}
char pop（）{
如果（顶部==-1）{
System.out.println（“错误：堆栈未流错误”）；
返回“\0”；
}
否则{
char元素=括号[顶部]；
顶部--；
返回元素；
}
}
布尔isEmpty（）{
返回值（top==-1）？真：假；
}
}
静态布尔isMatchingPair（char-bracketOne，char-bracketTwo）{
if（brackettone=='（'&&brackettown=='））{
返回true；
}
else if（brackettone='{'&&bracketwo='}'）{
返回true；
}
else if（brackettone=='['&&bracketwo==']'）{
返回true；
}
否则{
返回false；
}
}
静态布尔值isBalanced（字符串表达式）{
MyArrayStack st=新建MyArrayStack（）；
对于（int index=0；index非常奇怪的代码tbh。。。
就像一个字符串一样读取它。转换为字符数组。三个整数表示（，{，[.如果字符是），}，]，然后在相应的整数上执行-1。如果所有三个整数都是0，则该项是正确的

public static boolean validate(String s) {
    int bracket = 0;
    int squareBracket = 0;
    int brace = 0;
    for(char c : s.toCharArray()) {
        switch (c) {
            case '(': bracket++; break;
            case ')': bracket--; break;
            case '[': squareBracket++; break;
            case ']': squareBracket--; break;
            case '{': brace++; break;
            case '}': brace--; break;
            default: break;
        }
    }
    return(bracket == 0 && squareBracket == 0 && brace == 0);
}

非常奇怪的代码tbh。。。
就像一个字符串一样读取它。转换为字符数组。三个整数表示（，{，[.如果字符是），}，]，然后在相应的整数上执行-1。如果所有三个整数都是0，则该项是正确的

public static boolean validate(String s) {
    int bracket = 0;
    int squareBracket = 0;
    int brace = 0;
    for(char c : s.toCharArray()) {
        switch (c) {
            case '(': bracket++; break;
            case ')': bracket--; break;
            case '[': squareBracket++; break;
            case ']': squareBracket--; break;
            case '{': brace++; break;
            case '}': brace--; break;
            default: break;
        }
    }
    return(bracket == 0 && squareBracket == 0 && brace == 0);
}

请参见注释中的逻辑缺陷：

// why are we checking for `{` twice here?
if(expression.charAt(index)=='{'|| expression.charAt(index)=='(' || expression.charAt(index)=='{') {
    st.push(expression.charAt(index));
} // missing 'else' here, maybe??
// why are we checking for `}` twice here?
if(expression.charAt(index)=='}'|| expression.charAt(index)==')'||expression.charAt(index)=='}'){
    if(st.isEmpty()) {
        return false;
    }
    // shouldn't we be calling pop() and isMatchingPair() here?
}
// here we know that charAt(index) is not a ')' or '}',
// so why are we calling pop() and isMatchingPair()?
else if(!isMatchingPair(st.pop(),expression.charAt(index))) {
    return false;
}

为了获得更好的性能和代码清晰度，只需调用一次
expression.charAt（index）

char ch = expression.charAt(index);
if (ch == '(' || ch == '{' || ch == '[') {
    st.push(ch);
} else if (ch == ')' || ch == '}' || ch == ']'){
    if (st.isEmpty()) {
        return false;
    }
    if (! isMatchingPair(st.pop(), ch)) {
        return false;
    }
}

请参见注释中的逻辑缺陷：

// why are we checking for `{` twice here?
if(expression.charAt(index)=='{'|| expression.charAt(index)=='(' || expression.charAt(index)=='{') {
    st.push(expression.charAt(index));
} // missing 'else' here, maybe??
// why are we checking for `}` twice here?
if(expression.charAt(index)=='}'|| expression.charAt(index)==')'||expression.charAt(index)=='}'){
    if(st.isEmpty()) {
        return false;
    }
    // shouldn't we be calling pop() and isMatchingPair() here?
}
// here we know that charAt(index) is not a ')' or '}',
// so why are we calling pop() and isMatchingPair()?
else if(!isMatchingPair(st.pop(),expression.charAt(index))) {
    return false;
}

为了获得更好的性能和代码清晰度，只需调用一次
expression.charAt（index）

char ch = expression.charAt(index);
if (ch == '(' || ch == '{' || ch == '[') {
    st.push(ch);
} else if (ch == ')' || ch == '}' || ch == ']'){
    if (st.isEmpty()) {
        return false;
    }
    if (! isMatchingPair(st.pop(), ch)) {
        return false;
    }
}

你试过使用调试器吗？你试过使用调试器吗？谢谢你，你的代码最终解决了问题，请你解释一下代码中的else if语句部分好吗？我理解错误的语句，但我对如果两个字符都像[and]@Gtown一样匹配会发生什么感到困惑，因为
ch
不能同时是
[
和
]
else

没有明显的效果，它只是告诉编译器，如果第一次检查开括号是真的，就不需要检查闭括号。这是一个微观的性能改进，但实际上是一个逻辑改进，可以说我们已经完成了

if elseif else

构造。这对我来说很重要f我们在最后有一个

else

，就像你原来的代码一样。对于这个代码来说，这并不重要，但是养成这样编写好的逻辑的习惯是很好的。谢谢你，你的代码最终解决了这个问题，你能解释一下代码中的else if语句部分吗？我理解错误的语句，但我对什么感到困惑如果两个字符都匹配，例如[and]@Gtown，则会发生，因为

ch

不能同时是

[

和

]

else没有明显的效果，它只是告诉编译器，如果第一次检查开括号是真的，就不需要检查闭括号。这是一个微观的性能改进，但实际上是一个逻辑改进，可以说我们已经完成了

if elseif else

构造。这对我来说很重要如果我们在最后有一个

else

，就像你原来的代码一样。对于这个代码来说，这并不重要，但是养成这样编写好的逻辑的习惯是很好的。这是行不通的。

{a+（b+c}）

将是有效的否，你创建了三个整数：一个为（），一个为[]，一个为{}。对于每个左括号，您对相应的整数执行+1操作，对于右括号-1。如果所有三个整数的结尾都是0，则字符串是有效的。是的，因此在我的示例中，它将返回0，但括号在括号之前是闭合的，因此无效。您的代码只检查左括号/右括号字符的数量，而不是它们的一致性（即：如果前一个开头字符是圆括号，则检查下一个结束字符是否是圆括号）这是正确的。然后您也可以将所有括号写入一个字符数组，然后从头到尾读取字符。如果chararray.length%2！=0，那么您可以直接返回false。这不起作用。

{a+（b+c}）

将是有效的否，您将创建三个整数：一个用于（），一个用于[]，一个用于{}。对于每个左括号，您对相应的整数执行+1操作，对于右括号-1。如果所有三个整数的结尾都是0，则字符串是有效的。是的，因此在我的示例中，它将返回0，但括号在括号之前是闭合的，因此无效。您的代码只检查左括号/右括号字符的数量，而不是它们的一致性（即：如果前一个开头字符是括号，则检查下一个结束字符是否是括号）。使用

“（{）}”

测试您的代码是否正确。然后您还可以将所有括号写入一个字符数组，然后从头到尾读取字符。如果chararray.length%2！=0，