在 Java 中判断一个字符串是否为有效的 JSON 格式，主要有以下几种方法，它们各有优劣，适用于不同的场景。

使用 org.json 库 (简单直接)

这是最常用和最简单的方法之一,你需要先添加 org.json 库的依赖。

添加依赖 (Maven)

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20251013</version> <!-- 使用最新版本 -->
</dependency>

代码示例

org.json 库提供了一个 JSONException，我们可以尝试解析字符串，如果捕获到这个异常，就说明字符串不是有效的 JSON。

import org.json.JSONException;
import org.json.JSONObject;
public class JsonValidator {
    /**
     * 使用 org.json 库判断字符串是否为有效的 JSON 对象
     * @param jsonString 要检查的字符串
     * @return 如果是有效的 JSON 对象则返回 true，否则返回 false
     */
    public static boolean isValidJsonObject(String jsonString) {
        if (jsonString == null || jsonString.trim().isEmpty()) {
            return false;
        }
        try {
            new JSONObject(jsonString);
            return true;
        } catch (JSONException e) {
            return false;
        }
    }
    /**
     * 使用 org.json 库判断字符串是否为有效的 JSON 数组
     * @param jsonString 要检查的字符串
     * @return 如果是有效的 JSON 数组则返回 true，否则返回 false
     */
    public static boolean isValidJsonArray(String jsonString) {
        if (jsonString == null || jsonString.trim().isEmpty()) {
            return false;
        }
        try {
            new org.json.JSONArray(jsonString);
            return true;
        } catch (JSONException e) {
            return false;
        }
    }
    /**
     * 判断字符串是否为有效的 JSON (对象或数组)
     * @param jsonString 要检查的字符串
     * @return 如果是有效的 JSON 对象或数组则返回 true，否则返回 false
     */
    public static boolean isValidJson(String jsonString) {
        return isValidJsonObject(jsonString) || isValidJsonArray(jsonString);
    }
    public static void main(String[] args) {
        String validObject = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";
        String validArray = "[\"apple\", \"banana\", \"cherry\"]";
        String invalidJson = "{name: 'John', age: 30}"; // 属性名必须双引号
        String plainText = "This is just a plain string.";
        System.out.println("Is '" + validObject + "' valid JSON? " + isValidJson(validObject)); // true
        System.out.println("Is '" + validArray + "' valid JSON? " + isValidJson(validArray));   // true
        System.out.println("Is '" + invalidJson + "' valid JSON? " + isValidJson(invalidJson)); // false
        System.out.println("Is '" + plainText + "' valid JSON? " + isValidJson(plainText));   // false
    }
}

使用 Jackson 或 Gson 库 (更强大，与项目集成度高)

如果你的项目已经在使用 Jackson 或 Gson 进行 JSON 序列化/反序列化，那么直接使用它们来校验是最自然的选择。

使用 Jackson

首先添加 Jackson 依赖 (Maven):

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version> <!-- 使用最新版本 -->
</dependency>

代码示例：

Jackson 的核心类是 ObjectMapper，我们可以调用其 readTree() 方法，它会返回一个 JsonNode，如果解析失败，会抛出 JsonProcessingException。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonJsonValidator {
    private static final ObjectMapper objectMapper = new ObjectMapper();
    public static boolean isValidJson(String jsonString) {
        if (jsonString == null || jsonString.trim().isEmpty()) {
            return false;
        }
        try {
            objectMapper.readTree(jsonString);
            return true;
        } catch (JsonProcessingException e) {
            return false;
        }
    }
    public static void main(String[] args) {
        String validJson = "{\"name\": \"John\", \"age\": 30}";
        String invalidJson = "{name: 'John', age: 30}";
        System.out.println("Is '" + validJson + "' valid JSON? " + isValidJson(validJson)); // true
        System.out.println("Is '" + invalidJson + "' valid JSON? " + isValidJson(invalidJson)); // false
    }
}

使用 Gson

首先添加 Gson 依赖 (Maven):

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version> <!-- 使用最新版本 -->
</dependency>

代码示例：

Gson 的核心类是 JsonParser，我们可以调用其 parse() 方法，它会返回一个 JsonElement，如果解析失败，会抛出 JsonSyntaxException。

import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;
public class GsonJsonValidator {
    public static boolean isValidJson(String jsonString) {
        if (jsonString == null || jsonString.trim().isEmpty()) {
            return false;
        }
        try {
            JsonParser.parseString(jsonString);
            return true;
        } catch (JsonSyntaxException e) {
            return false;
        }
    }
    public static void main(String[] args) {
        String validJson = "{\"name\": \"John\", \"age\": 30}";
        String invalidJson = "{name: 'John', age: 30}";
        System.out.println("Is '" + validJson + "' valid JSON? " + isValidJson(validJson)); // true
        System.out.println("Is '" + invalidJson + "' valid JSON? " + isValidJson(invalidJson)); // false
    }
}

使用 Java 8 的 javax.json (JSR 374) API (标准 API)

这是 Java 官方的 JSON 处理标准 API，如果你不想引入第三方库，这是一个不错的选择。

添加依赖 (Maven)

javax.json 通常需要你选择一个具体的实现，org.glassfish。

<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.json</artifactId>
    <version>1.1.4</version>
</dependency>

代码示例

javax.json 提供了 JsonReader，我们可以尝试用它来解析字符串，如果解析失败，会抛出 JsonException。

import javax.json.Json;
import javax.json.JsonReader;
import java.io.StringReader;
public class JavaxJsonValidator {
    public static boolean isValidJson(String jsonString) {
        if (jsonString == null || jsonString.trim().isEmpty()) {
            return false;
        }
        try (JsonReader reader = Json.createReader(new StringReader(jsonString))) {
            reader.read(); // 尝试读取，如果成功则说明是有效的
            return true;
        } catch (Exception e) {
            // JsonException 或其他解析异常
            return false;
        }
    }
    public static void main(String[] args) {
        String validJson = "{\"name\": \"John\", \"age\": 30}";
        String invalidJson = "{name: 'John', age: 30}";
        System.out.println("Is '" + validJson + "' valid JSON? " + isValidJson(validJson)); // true
        System.out.println("Is '" + invalidJson + "' valid JSON? " + isValidJson(invalidJson)); // false
    }
}

总结与对比

如何选择？

• 如果你只是想快速判断一个字符串是不是 JSON，并且不想引入太大的库，org.json 是最佳选择。
• 如果你的项目已经使用了 Jackson 或 Gson，直接使用它们进行校验是最自然、最统一的方案。
• 如果你是 Java 新手，或者追求最标准的实现，可以考虑 javax.json，但请注意它的 API 可能不如其他库友好。

对于绝大多数 Java org.json 或 Jackson 是判断 JSON 格式的最常用和推荐的方法。