Java中基于栈验证JSON字符串结构有效性的方法

import java.util.Stack;

public class JsonValidator {

    public static boolean isValidJSON(String jsonString) {
        Stack<Character> stack = new Stack<>();
        for (char c : jsonString.toCharArray()) {
            switch (c) {
                case '{':
                    stack.push(c);
                    break;
                case '}':
                    if (stack.isEmpty()) {
                        return false;
                    }
                    Character last1 = stack.pop();
                    if (last1 != '{') {
                        return false;
                    }
                    break;
                case '[':
                    stack.push(c);
                    break;
                case ']':
                    if (stack.isEmpty()) {
                        return false;
                    }
                    Character last2 = stack.pop();
                    if (last2 != '[') {
                        return false;
                    }
                    break;
                case '"':
                    // 这里的逻辑存在多处问题
                    if (stack.isEmpty()) {
                        // 错误：如果字符串以双引号开始，栈是空的，会直接返回false
                        return false;
                    }
                    Character last3 = stack.peek();
                    if (last3 == '"') {
                        stack.pop(); // 期望是匹配一个开引号
                    } else {
                        stack.push(c); // 期望是压入一个开引号
                    }
                    // 核心问题：无论上面if-else分支如何，这里总是会再次压入双引号
                    stack.push(c);
                    break;
            }
        }
        return stack.isEmpty();
    }
}

import java.util.Stack;

public class JsonValidatorImproved {

    /**
     * 验证JSON字符串的结构有效性（仅限括号和引号的平衡与嵌套）
     * 不进行完整的JSON语法验证（如键值对格式、数据类型有效性等）
     *
     * @param jsonString 待验证的JSON字符串
     * @return 如果结构平衡且嵌套正确，则返回true；否则返回false。
     */
    public static boolean isValidJSONStructure(String jsonString) {
        Stack<Character> stack = new Stack<>();
        boolean inString = false; // 标记当前是否在双引号字符串内部

        for (int i = 0; i < jsonString.length(); i++) {
            char c = jsonString.charAt(i);

            // 如果当前在字符串内部
            if (inString) {
                // 处理转义字符：如果遇到反斜杠，跳过下一个字符
                if (c == '\') {
                    i++; // 跳过下一个字符，因为它是转义序列的一部分
                    if (i >= jsonString.length()) { // 防止字符串在转义符后结束，导致越界
                        return false; // 非法转义序列
                    }
                    continue; // 继续处理下一个字符
                }
                // 遇到未转义的双引号，表示字符串结束
                if (c == '"') {
                    inString = false;
                }
                // 字符串内部的其他字符（包括 { } [ ]）不影响结构匹配，直接跳过
                continue;
            }

            // 不在字符串内部时，处理结构字符
            switch (c) {
                case '{':
                case '[':
                    stack.push(c); // 遇到开符号，压入栈
                    break;
                case '}':
                    if (stack.isEmpty() || stack.pop() != '{') {
                        return false; // 栈为空或栈顶不匹配，结构无效
                    }
                    break;
                case ']':
                    if (stack.isEmpty() || stack.pop() != '[') {
                        return false; // 栈为空或栈顶不匹配，结构无效
                    }
                    break;
                case '"':
                    inString = true; // 遇到双引号，进入字符串模式
                    break;
                // 忽略其他字符，如逗号、冒号、空格、数字、布尔值、null等。
                // 这些字符在结构验证中不影响括号平衡，但完整的JSON验证需要检查它们。
                case ' ':
                case '	':
                case '
':
                case '
':
                case ',':
                case ':':
                    break; // 忽略空白符、逗号和冒号
                default:
                    // 对于不在字符串内部的非结构字符，如果不是合法JSON值的一部分，
                    // 这里可以根据需求返回false，但对于纯粹的结构平衡验证，可以忽略。
                    // 为了简化，我们只关注括号和引号的平衡。
                    // 实际的JSON解析器会在这里进行更严格的字符检查。
                    // 例如，如果是非数字、非布尔、非null的裸字符，可能是语法错误。
                    // 为了本教程的目的，我们假设这些字符要么是合法值的一部分，要么是外部的非结构字符。
                    break;
            }
        }
        // 最终检查：栈必须为空，且不能停留在字符串内部
        return stack.isEmpty() && !inString;
    }

    public static void main(String[] args)