在 Java 开发中，处理 JSON 数据是一项常见任务，而遍历 JSON 是其中的核心操作，无论是从 API 接收数据、解析配置文件，还是处理前后端交互的 JSON 格式数据，掌握高效的遍历方法都至关重要，本文将系统介绍 Java 中遍历 JSON 的多种方式，包括使用原生库、第三方工具以及不同场景下的最佳实践,帮助开发者根据需求选择合适的方案。
使用 org.json 库遍历 JSON
org.json 是一个轻量级的 Java JSON 处理库，提供了简单易用的 API 来解析和遍历 JSON 数据，其核心类包括 JSONObject（表示 JSON 对象）和 JSONArray（表示 JSON 数组），通过递归或迭代方式可实现灵活遍历。
遍历 JSON 对象
对于 JSON 对象（如 {"name":"张三","age":25}），可通过 keys() 方法获取键集合，再结合 get() 方法获取值，示例代码如下：
import org.json.JSONObject;
public class JSONObjectTraversal {
public static void main(String[] args) {
String jsonStr = "{\"name\":\"张三\",\"age\":25,\"hobbies\":[\"阅读\",\"编程\"]}";
JSONObject jsonObject = new JSONObject(jsonStr);
// 遍历键值对
for (String key : jsonObject.keySet()) {
Object value = jsonObject.get(key);
System.out.println("键: " + key + ", 值: " + value);
// 处理嵌套的 JSONArray
if (value instanceof JSONArray) {
JSONArray jsonArray = (JSONArray) value;
System.out.println("遍历数组:");
for (int i = 0; i < jsonArray.length(); i++) {
System.out.println(" 元素 " + i + ": " + jsonArray.get(i));
}
}
}
}
}
上述代码中，keySet() 返回所有键的迭代器，get(key) 根据键获取值，若值为 JSONArray 类型，需进一步遍历数组元素。
遍历 JSON 数组
对于 JSON 数组（如 [{"id":1},{"id":2}]），可通过 length() 获取数组长度，再通过 get(index) 获取元素，示例：
import org.json.JSONArray;
public class JSONArrayTraversal {
public static void main(String[] args) {
String jsonStr = "[{\"id\":1,\"name\":\"商品A\"},{\"id\":2,\"name\":\"商品B\"}]";
JSONArray jsonArray = new JSONArray(jsonStr);
for (int i = 0; i < jsonArray.length(); i++) {
JSONObject item = jsonArray.getJSONObject(i);
System.out.println("商品ID: " + item.getInt("id") + ", 名称: " + item.getString("name"));
}
}
}
使用 Gson 库遍历 JSON
Gson 是 Google 提供的 JSON 处理库，支持将 JSON 直接转换为 Java 对象（反序列化），也可通过 JsonElement 和 JsonParser 实现灵活遍历，无需提前定义实体类。
基于 JsonElement 递归遍历
Gson 的 JsonElement 是 JSON 的抽象表示，包括 JsonObject、JsonArray、JsonPrimitive（基本类型）和 JsonNull 四种子类，通过递归可遍历任意层级的 JSON：
import com.google.gson.*;
public class GsonTraversal {
public static void main(String[] args) {
String jsonStr = "{\"user\":{\"name\":\"李四\",\"contacts\":[{\"type\":\"phone\",\"number\":\"13800138000\"}]}}";
JsonElement jsonElement = JsonParser.parseString(jsonStr);
traverseJson(jsonElement, 0);
}
public static void traverseJson(JsonElement element, int level) {
String indent = " ".repeat(level); // 缩进格式化
if (element.isJsonObject()) {
JsonObject jsonObject = element.getAsJsonObject();
System.out.println(indent + "{");
for (Map.Entry<String, JsonElement> entry : jsonObject.entrySet()) {
System.out.println(indent + " " + entry.getKey() + ":");
traverseJson(entry.getValue(), level + 1);
}
System.out.println(indent + "}");
} else if (element.isJsonArray()) {
JsonArray jsonArray = element.getAsJsonArray();
System.out.println(indent + "[");
for (JsonElement item : jsonArray) {
traverseJson(item, level + 1);
}
System.out.println(indent + "]");
} else if (element.isJsonPrimitive()) {
System.out.println(indent + element.getAsString());
}
}
}
上述代码通过递归处理 JsonObject 和 JsonArray，实现带缩进的层级化遍历，适合调试或日志打印场景。
转换为 Map/List 遍历
若需将 JSON 转换为 Java 集合进行遍历，可通过 Gson 的 fromJson() 方法实现：
import com.google.gson.reflect.TypeToken;
import java.util.*;
public class GsonToCollection {
public static void main(String[] args) {
String jsonStr = "{\"key1\":\"value1\",\"key2\":[1,2,3]}";
Gson gson = new Gson();
Map<String, Object> data = gson.fromJson(jsonStr, new TypeToken<Map<String, Object>>(){}.getType());
for (Map.Entry<String, Object> entry : data.entrySet()) {
System.out.println("键: " + entry.getKey() + ", 值类型: " + entry.getValue().getClass().getSimpleName());
if (entry.getValue() instanceof List) {
List<?> list = (List<?>) entry.getValue();
System.out.println(" 列表元素: " + list);
}
}
}
}
使用 Jackson 库遍历 JSON
Jackson 是高性能的 JSON 处理库，广泛用于 Spring 等框架，其核心类 JsonNode 提供了树形遍历模型，无需反序列化即可操作 JSON。
基于 JsonNode 遍历
JsonNode 是 Jackson 的树模型节点，支持 fields()（遍历对象字段）、elements()（遍历数组元素）等方法：
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonTraversal {
public static void main(String[] args) throws Exception {
String jsonStr = "{\"name\":\"王五\",\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\"}}";
ObjectMapper mapper = new ObjectMapper();
JsonNode rootNode = mapper.readTree(jsonStr);
// 遍历对象字段
rootNode.fields().forEachRemaining(entry -> {
String key = entry.getKey();
JsonNode value = entry.getValue();
System.out.println("键: " + key);
if (value.isObject()) {
System.out.println(" 嵌套对象:");
value.fields().forEachRemaining(nestedEntry -> {
System.out.println(" " + nestedEntry.getKey() + ": " + nestedEntry.getValue());
});
} else {
System.out.println(" 值: " + value.asText());
}
});
}
}
使用 TreeTraverser 递归遍历
Jackson 提供了 TreeTraverser 工具类，支持深度优先或广度优先遍历：
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.util.TreeTraverser;
public class JacksonTreeTraverser {
public static void main(String[] args) throws Exception {
String jsonStr = "{\"a\":1,\"b\":{\"c\":2,\"d\":[3,4]}}";
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(jsonStr);
TreeTraverser<JsonNode> traverser = new TreeTraverser<JsonNode>() {
@Override
public Iterable<JsonNode> children(JsonNode parent) {
List<JsonNode> children = new ArrayList<>();
if (parent.isObject()) {
parent.forEach(children::add);
} else if (parent.isArray()) {
parent.forEach(children::add);
}
return children;
}
};
System.out.println("深度优先遍历:");
traverser.depthFirstTraversal(node).forEach(n -> {
System.out.println("节点: " + n.asText());
});
}
}
遍历 JSON 的最佳实践
-
选择合适的库：
- 简单场景：优先使用
org.json，轻量且 API 简单； - 复杂对象映射：选择
Gson或Jackson，支持自动反序列化； - 高性能需求：推荐
Jackson，解析速度快，内存占用低。
- 简单场景：优先使用
-
处理嵌套结构：递归或迭代方式均可，但需注意递归深度过大可能导致栈溢出，可通过循环+栈结构优化。
-
异常处理：JSON 解析时可能抛出
JSONException（org.json）、JsonSyntaxException（Gson）或JsonProcessingException（Jackson），需捕获并处理异常。 -
性能优化：避免频繁创建
ObjectMapper（Jackson）或Gson实例，建议复用；大文件解析时使用流式 API（如 Jackson 的JsonParser）。
Java 中遍历 JSON 的方法多样，从轻量级的 org.json 到功能强大的 Gson 和 Jackson，开发者可根据项目需求选择合适的工具，掌握递归、迭代以及树形模型等遍历技巧，能高效处理复杂 JSON 结构，提升开发效率，在实际应用中，还需结合异常处理、性能优化等实践,确保代码的健壮性和可维护性。
