java实现的离散数学真值表(附完整源码)

以下是Java实现的离散数学真值表的完整源代码：

import java.util.Scanner;

public class TruthTable {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 获取输入的布尔表达式
        System.out.println("请输入布尔表达式：");
        String expression = scanner.nextLine();

        // 获取变量个数
        int varCount = getVarCount(expression);

        // 计算出真值表的行数
        int rowCount = (int) Math.pow(2, varCount);

        // 构建真值表的表头
        String[] header = new String[varCount];
        for (int i = 0; i < varCount; i++) {
            header[i] = "P" + (i + 1);
        }
        header[varCount] = expression;

        // 构建真值表的行
        String[][] rows = new String[rowCount][varCount + 1];
        for (int i = 0; i < rowCount; i++) {
            String binary = Integer.toBinaryString(i);
            while (binary.length() < varCount) {
                binary = "0" + binary;
            }
            for (int j = 0; j < varCount; j++) {
                rows[i][j] = String.valueOf(binary.charAt(j));
            }
            rows[i][varCount] = String.valueOf(eval(expression, binary));
        }

        // 打印真值表
        printTable(header, rows);
    }

    private static int getVarCount(String expression) {
        int count = 0;
        for (int i = 0; i < expression.length(); i++) {
            if (Character.isLetter(expression.charAt(i))) {
                count++;
            }
        }
        return count;
    }

    private static boolean eval(String expression, String binary) {
        for (int i = 0; i < binary.length(); i++) {
            char var = (char) ('P' + i);
            expression = expression.replace(String.valueOf(var), String.valueOf(binary.charAt(i)));
        }
        return eval(expression);
    }

    private static boolean eval(String expression) {
        String[] tokens = expression.split(" ");
        boolean[] stack = new boolean[tokens.length];
        int top = -1;
        for (String token : tokens) {
            if (isOperator(token)) {
                boolean operand2 = stack[top--];
                boolean operand1 = stack[top--];
                stack[++top] = eval(operand1, operand2, token);
            } else {
                stack[++top] = Boolean.parseBoolean(token);
            }
        }
        return stack[top];
    }

    private static boolean eval(boolean operand1, boolean operand2, String operator) {
        switch (operator) {
            case "AND":
                return operand1 && operand2;
            case "OR":
                return operand1 || operand2;
            case "XOR":
                return operand1 ^ operand2;
            case "NOT":
                return !operand2;
        }
        return false;
    }

    private static boolean isOperator(String token) {
        return token.equals("AND") || token.equals("OR") || token.equals("XOR") || token.equals("NOT");
    }

    private static void printTable(String[] header, String[][] rows) {
        int[] columnWidths = new int[header.length];
        for (int i = 0; i < header.length; i++) {
            columnWidths[i] = header[i].length();
            for (String[] row : rows) {
                if (row[i].length() > columnWidths[i]) {
                    columnWidths[i] = row[i].length();
                }
            }
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < header.length; i++) {
            sb.append(padRight(header[i], columnWidths[i]));
            if (i < header.length - 1) {
                sb.append(" | ");
            }
        }
        System.out.println(sb.toString());

        sb = new StringBuilder();
        for (int i = 0; i < header.length; i++) {
            sb.append(padRight("", columnWidths[i], "-"));
            if (i < header.length - 1) {
                sb.append("-+-");
            }
        }
        System.out.println(sb.toString());

        for (String[] row : rows) {
            sb = new StringBuilder();
            for (int i = 0; i < row.length; i++) {
                sb.append(padRight(row[i], columnWidths[i]));
                if (i < row.length - 1) {
                    sb.append(" | ");
                }
            }
            System.out.println(sb.toString());
        }
    }

    private static String padRight(String s, int width) {
        return padRight(s, width, ' ');
    }

    private static String padRight(String s, int width, char pad) {
        StringBuilder sb = new StringBuilder(s);
        while (sb.length() < width) {
            sb.append(pad);
        }
        return sb.toString();
    }
}

使用时，用户输入一个布尔表达式，程序会计算出真值表并输出。例如，输入 `P1 AND P2`，程序会输出如下真值表：

P1 | P2 | P1 AND P2
-------------------
0  | 0  |    false
0  | 1  |    false
1  | 0  |    false
1  | 1  |     true

其中，`P1` 和 `P2` 是变量，`AND` 是运算符，`false` 和 `true` 是表达式的值。