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() || stack.pop() != '{') {
                        return false;
                    }
                    break;
                case '[':
                    stack.push(c);
                    break;
                case ']':
                    if (stack.isEmpty() || stack.pop() != '[') {
                        return false;
                    }
                    break;
                case '"':
                    // 问题区域：引号处理逻辑不当
                    if (stack.isEmpty()) { // 此处判断不合理，双引号可以是字符串的起始
                        return false;
                    }
                    Character last3 = stack.peek();
                    if (last3 == '"') { // 尝试匹配栈顶的引号
                        stack.pop();
                    } else { // 如果栈顶不是引号，则压入当前引号
                        stack.push(c);
                    }
                    stack.push(c); // 错误：这里无论如何都会再次压入当前引号
            }
        }
        return stack.isEmpty();
    }
}

import java.util.Stack;

public class JsonValidatorImproved {

    public static boolean isValidJSON(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;
                    }
                    // 实际的JSON解析器会检查转义字符的有效性，这里仅跳过
                } else if (c == '"') {
                    inString = false; // 退出字符串模式
                }
                // 字符串内部的其他字符不影响栈操作
            } else {
                // 不在字符串内部，处理结构性字符
                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;
                    // 忽略空白字符
                    case ' ':
                    case '
':
                    case '
':
                    case '	':
                        break;
                    // 对于其他非结构性字符（如数字、布尔值、null、逗号、冒号），
                    // 一个简单的栈平衡检查器通常会忽略它们。
                    // 完整的JSON解析器需要更复杂的逻辑来验证这些值的语法。
                    default:
                        // 这是一个简化处理。在真正的JSON验证器中，
                        // 这些字符需要被识别为有效的JSON值的一部分（如数字、布尔值、null）。
                        // 如果它们不属于任何有效token，则应返回false。
                        // 本示例主要关注括号和引号的平衡。
                        break;
                }
            }
        }

        // 遍历结束后，如果仍在字符串内部，或者栈不为空，则JSON无效
        return !inString && stack.isEmpty();
    }
}