Java堆栈布尔输出定制？

所以我有一个稍微修改过的代码版本，它是Java堆栈平衡的一百倍

import java.util.Stack;

public class Main {

public static String testContent = "{(a,b)}";

public static void main(String args[])
{

    System.out.println(balancedParentheses(testContent));
}

public static boolean balancedParentheses(String s)
{
    Stack<Character> stack  = new Stack<Character>();
    for(int i = 0; i < s.length(); i++)
    {
        char c = s.charAt(i);
        if(c == '[' || c == '(' || c == '{' )
        {
            stack.push(c); 
        }else if(c == ']')
        {
            if(stack.isEmpty()) return false;
            if(stack.pop() != '[') return false;

        }else if(c == ')')
        {
            if(stack.isEmpty()) return false;
            if(stack.pop() != '(') return false;

        }else if(c == '}')
        {
            if(stack.isEmpty()) return false;
            if(stack.pop() != '{') return false;
        }

    }
    return stack.isEmpty(); 
}
}

import java.util.Stack；
公共班机{
公共静态字符串testContent=“{（a，b）}”；
公共静态void main（字符串参数[]）
{
System.out.println（平衡页（测试内容））；
}
公共静态布尔平衡参数（字符串s）
{
堆栈=新堆栈（）；
对于（int i=0；i

---

我想做的是定制输出，使其输出类似于“平衡”或“不平衡”而不是true/false。尝试用包含“balanced”的System.println替换return false；，会给我很多我不想要的输出行。在这里搜索了大约一个小时，做了一些更改，但没有找到我想要的答案。有什么见解吗？

你可以使用

System.out.println（平衡的论题（测试内容）-“平衡的”：“不平衡的”）；

或者，如果需要返回字符串的方法，请将逻辑包装到另一个方法中

String isBalanced(String expression) {
    return balancedParentheses(expression) ? "balanced" : "imbalanced"
}

主要是()

您也可以这样编写代码

public static boolean balancedParentheses(String s) {
    Stack<Character> stack = new Stack<Character>();
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (c == '[' || c == '(' || c == '{') {
            stack.push(c);
        } else if (c == ']' || c == ')' || c == '}') {
            if (stack.isEmpty() || !matches(stack.pop(), c))
                return false;
        } 
    }
    return stack.isEmpty();
}

private static boolean matches(char opening, char closing) {
    return opening == '{' && closing == '}' ||
            opening == '(' && closing == ')' ||
            opening == '[' && closing == ']';
}

公共静态布尔平衡参数（字符串s）{
堆栈=新堆栈（）；
对于（int i=0；i

System.out.println（balancedparenthesis（testContent）？“balanced”：unbalanced”）；出于某种原因，我无法将此标记为解决方案，但它确实起到了作用。谢谢你！@BEASTthisIndustry这是因为在堆栈溢出时你不能接受评论，但你可以接受答案我喜欢你简洁的balancedparenthesis（）代码！我会使用类似于

“[（{）.contains（c）

的东西，在matches方法中

字符串方括号=开始+结束；

然后执行

方括号。等于（“（）”）|方括号。等于（“[”）

等等。。。

public static boolean balancedParentheses(String s) {
    Stack<Character> stack = new Stack<Character>();
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (c == '[' || c == '(' || c == '{') {
            stack.push(c);
        } else if (c == ']' || c == ')' || c == '}') {
            if (stack.isEmpty() || !matches(stack.pop(), c))
                return false;
        } 
    }
    return stack.isEmpty();
}

private static boolean matches(char opening, char closing) {
    return opening == '{' && closing == '}' ||
            opening == '(' && closing == ')' ||
            opening == '[' && closing == ']';
}