java 将字符串解析为逻辑表达式，字符串中包括括号，and or

可以使用逆波兰表达式来实现将字符串解析为逻辑表达式的功能。具体步骤如下：

1. 将字符串转换为中缀表达式。

2. 将中缀表达式转换为后缀表达式（逆波兰表达式）。

3. 通过栈的操作，计算逆波兰表达式的值。

以下是 Java 代码示例：

import java.util.*;

public class LogicExpressionParser {
    public static boolean parse(String input) {
        String postfix = infixToPostfix(input);
        Stack<Boolean> stack = new Stack<>();
        for (int i = 0; i < postfix.length(); i++) {
            char ch = postfix.charAt(i);
            if (ch == ' ') continue;
            if (ch == 'T') stack.push(true);
            else if (ch == 'F') stack.push(false);
            else if (ch == 'and') {
                boolean a = stack.pop();
                boolean b = stack.pop();
                stack.push(a && b);
            } else if (ch == 'or') {
                boolean a = stack.pop();
                boolean b = stack.pop();
                stack.push(a || b);
            }
        }
        return stack.pop();
    }
    
    private static String infixToPostfix(String input) {
        StringBuilder output = new StringBuilder();
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);
            if (ch == ' ') continue;
            if (ch == '(') stack.push(ch);
            else if (ch == ')') {
                while (!stack.isEmpty() && stack.peek() != '(') {
                    output.append(stack.pop()).append(' ');
                }
                stack.pop(); // pop '('
            } else if (ch == 'T' || ch == 'F') {
                output.append(ch).append(' ');
            } else if (ch == 'and' || ch == 'or') {
                while (!stack.isEmpty() && precedence(stack.peek()) >= precedence(ch)) {
                    output.append(stack.pop()).append(' ');
                }
                stack.push(ch);
            }
        }
        while (!stack.isEmpty()) {
            output.append(stack.pop()).append(' ');
        }
        return output.toString();
    }
    
    private static int precedence(char ch) {
        if (ch == 'or') return 1;
        if (ch == 'and') return 2;
        return 0;
    }
}

使用示例：

String input = "((T and F) or (F and T))";
boolean result = LogicExpressionParser.parse(input);
System.out.println(result); // 输出 true

在以上示例中，输入字符串为逻辑表达式 ((T and F) or (F and T))，解析后得到逆波兰表达式 T F and F T and or，通过栈的操作计算得到 true。