在 Java 中判断一个字符串是否为有效的 JSON，有多种方法，适用于不同的场景和需求，下面我将从最简单到最健壮的方式,为你详细介绍几种主流的方案。
（图片来源网络，侵删）
使用 JSON 库进行解析（最推荐）
这是最可靠、最健壮的方法，通过尝试将字符串解析为 JSON 对象或数组，如果解析成功，则说明是有效的 JSON；如果抛出异常,则说明无效。
使用 org.json 库（轻量级，适合简单场景）
org.json 是一个轻量级的 JSON 库,非常易于使用。
添加 Maven 依赖：
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20251013</version> <!-- 建议使用最新版本 -->
</dependency>
编写判断方法：
（图片来源网络，侵删）
import org.json.JSONException;
import org.json.JSONObject;
public class JsonValidator {
/**
* 使用 org.json 库判断字符串是否为有效的 JSON 对象
* @param str 要检查的字符串
* @return 如果是有效的 JSON 对象则返回 true，否则返回 false
*/
public static boolean isValidJsonObject(String str) {
if (str == null || str.isEmpty()) {
return false;
}
try {
new JSONObject(str);
return true;
} catch (JSONException e) {
return false;
}
}
/**
* 使用 org.json 库判断字符串是否为有效的 JSON 数组
* @param str 要检查的字符串
* @return 如果是有效的 JSON 数组则返回 true，否则返回 false
*/
public static boolean isValidJsonArray(String str) {
if (str == null || str.isEmpty()) {
return false;
}
try {
new org.json.JSONArray(str);
return true;
} catch (JSONException e) {
return false;
}
}
/**
* 判断字符串是否为有效的 JSON 对象或数组
* @param str 要检查的字符串
* @return 如果是有效的 JSON 对象或数组则返回 true，否则返回 false
*/
public static boolean isValidJson(String str) {
return isValidJsonObject(str) || isValidJsonArray(str);
}
public static void main(String[] args) {
String validObject = "{\"name\":\"John\", \"age\":30}";
String validArray = "[\"apple\", \"banana\", \"cherry\"]";
String invalidJson = "{name: 'John', age: 30}"; // 无效，属性名必须用双引号
String plainText = "This is just a plain text.";
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 库（功能强大，与框架集成度高）
如果你已经在使用 Spring Boot 等框架，那么项目中很可能已经包含了 Jackson 或 Gson，它们是功能更全面的 JSON 处理库。
使用 Jackson
添加 Maven 依赖：
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version> <!-- 建议使用最新版本 -->
</dependency>
编写判断方法：
Jackson 的核心是 ObjectMapper，我们可以尝试将字符串解析为 JsonNode，如果成功，就是有效的 JSON。
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonProcessingException;
public class JacksonJsonValidator {
private static final ObjectMapper objectMapper = new ObjectMapper();
public static boolean isValidJson(String str) {
if (str == null || str.trim().isEmpty()) {
return false;
}
try {
// 尝试将字符串解析为 JsonNode
JsonNode node = objectMapper.readTree(str);
// 如果没有抛出异常，说明解析成功
return true;
} catch (JsonProcessingException e) {
// 捕获 JsonProcessingException，说明不是有效的 JSON
return false;
}
}
public static void main(String[] args) {
String validObject = "{\"name\":\"John\", \"age\":30}";
String validArray = "[\"apple\", \"banana\", \"cherry\"]";
String invalidJson = "{name: 'John', age: 30}";
String plainText = "This is just a plain text.";
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
}
}
使用 Gson
添加 Maven 依赖：
（图片来源网络，侵删）
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version> <!-- 建议使用最新版本 -->
</dependency>
编写判断方法：
Gson 的 JsonParser 可以用来解析 JSON 字符串，如果解析成功，说明字符串是有效的 JSON。
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;
public class GsonJsonValidator {
public static boolean isValidJson(String str) {
if (str == null || str.trim().isEmpty()) {
return false;
}
try {
// JsonParser.parseString 在 Gson 2.8+ 中推荐使用
JsonElement element = JsonParser.parseString(str);
// 如果没有抛出异常，说明解析成功
return true;
} catch (JsonSyntaxException e) {
// 捕获 JsonSyntaxException，说明不是有效的 JSON
return false;
}
}
public static void main(String[] args) {
String validObject = "{\"name\":\"John\", \"age\":30}";
String validArray = "[\"apple\", \"banana\", \"cherry\"]";
String invalidJson = "{name: 'John', age: 30}";
String plainText = "This is just a plain text.";
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
}
}
使用正则表达式（不推荐，有局限性）
可以使用正则表达式进行初步的、非精确的判断，这种方法速度快，但无法保证 JSON 的语法完全正确，因为它不理解 JSON 的结构（字符串中的引号、转义字符等）。
示例代码：
public class RegexJsonValidator {
/**
* 使用正则表达式进行初步判断（不推荐）
* 这个正则表达式只能匹配非常简单的 JSON 结构，有严重局限性。
*/
public static boolean isValidJsonByRegex(String str) {
if (str == null || str.trim().isEmpty()) {
return false;
}
// 这个正则非常简单，只能处理最基本的情况
String jsonPattern = "^\\{.*\\}$|^\\[.*\\]$";
return str.trim().matches(jsonPattern);
}
public static void main(String[] args) {
String validObject = "{\"name\":\"John\", \"age\":30}";
String validArray = "[\"apple\", \"banana\", \"cherry\"]";
String invalidJson = "{name: 'John', age: 30}";
String plainText = "This is just a plain text.";
// 这个正则会把以下错误判断为有效
String invalidButMatchRegex = "{name: 'John', age: 30, \"city\": \"New\"}";
System.out.println("Is '" + validObject + "' valid JSON? " + isValidJsonByRegex(validObject)); // true
System.out.println("Is '" + validArray + "' valid JSON? " + isValidJsonByRegex(validArray)); // true
System.out.println("Is '" + invalidJson + "' valid JSON? " + isValidJsonByRegex(invalidJson)); // true (错误地判断为有效)
System.out.println("Is '" + plainText + "' valid JSON? " + isValidJsonByRegex(plainText)); // false
System.out.println("Is '" + invalidButMatchRegex + "' valid JSON? " + isValidJsonByRegex(invalidButMatchRegex)); // true (错误地判断为有效)
}
}
正则表达式只适合做非常粗糙的格式检查，以 开头并以 ，绝对不能用于生产环境来验证 JSON 的有效性。
总结与对比
| 方法 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| JSON 库解析 | 准确、健壮，能处理所有复杂的 JSON 语法（转义、嵌套等）。 | 需要引入额外的依赖，有轻微的性能开销（通常可忽略）。 | 所有推荐的生产环境场景，无论是 API 接口处理、配置文件解析还是数据交换，都应使用此方法。 |
| 正则表达式 | 无需依赖，速度极快。 | 不准确、有严重局限性，无法处理复杂的 JSON 结构，容易误判。 | 仅用于对性能要求极高且对 JSON 格式要求不严格的非关键性预检查，一般不推荐使用。 |
最终建议：
请务必使用方案一（JSON 库解析），这是行业标准，也是保证你代码健壮性和正确性的最佳实践，如果你已经在使用 Spring Boot，直接使用 Jackson 是最方便的选择；如果只是需要一个轻量级的工具，org.json 是绝佳的选择。
