Java中高效创建与操作JSON数组：从入门到实践的深度指南90

在现代软件开发中，JSON (JavaScript Object Notation) 已成为数据交换的事实标准。其轻量级、易读性强的特点使其在Web服务、API接口、配置文件以及跨语言数据传输等场景中无处不在。而JSON数组作为JSON数据结构的重要组成部分，常用于表示同类数据的集合，例如用户列表、商品清单或日志记录等。

对于Java开发者而言，虽然Java标准库没有内置的JSON处理能力，但幸运的是，社区提供了大量强大而成熟的第三方库来弥补这一不足。本文将作为一份深度指南，详细介绍如何在Java中高效、灵活地创建和操作JSON数组，涵盖主流的JSON处理库，并分享一些高级技巧和最佳实践。

JSON数组基础概念

JSON数组是一种有序的值集合，以方括号[]表示。数组中的每个元素可以是任意有效的JSON数据类型，包括字符串（"string"）、数字（123）、布尔值（true/false）、null、JSON对象（{}）或另一个JSON数组（[]）。

例如，一个包含字符串和数字的JSON数组：
[
"apple",
"banana",
"orange",
123,
45.67
]

一个包含JSON对象的JSON数组（最常见用例）：
[
{
"name": "Alice",
"age": 30,
"email": "alice@"
},
{
"name": "Bob",
"age": 24,
"email": "bob@"
}
]

一个嵌套的JSON数组：
[
[1, 2, 3],
["a", "b", "c"]
]

Java中的JSON处理库概述

在Java生态系统中，有几个库在JSON处理方面表现出色，各有侧重。我们将重点介绍以下几个：
Jackson: 功能最强大、性能最佳、使用最广泛的库之一。提供全面的数据绑定（Data Binding）、树模型（Tree Model）和流API（Streaming API）。
Gson: Google开发，简洁易用，特别适合将Java对象序列化为JSON以及将JSON反序列化为Java对象。
: 一个轻量级、自包含的库，功能相对基础，适合简单的JSON操作，但不如Jackson和Gson灵活和强大。
Jakarta JSON Processing (JSON-P): 作为JAX-RS 2.0 (Jakarta EE 8) 的一部分，提供了标准的JSON处理API，包括流API和对象模型API。

在使用这些库之前，您需要在项目的构建工具中添加相应的依赖。以下是Maven示例：

<dependency>
<groupId></groupId>
<artifactId>jackson-databind</artifactId>
<version>2.16.1</version> 
</dependency>

<dependency>
<groupId></groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version> 
</dependency>

<dependency>
<groupId></groupId>
<artifactId>json</artifactId>
<version>20231013</version> 
</dependency>

<dependency>
<groupId></groupId>
<artifactId></artifactId>
<version>2.1.1</version> 
</dependency>

使用Jackson库创建JSON数组

Jackson是Java中最流行的JSON库，提供了多种创建JSON数组的方式，包括数据绑定（POJO序列化）和树模型。

1. 数据绑定 (POJO序列化)

这是最常用和推荐的方式，将Java集合（如List, Set, 数组）直接序列化为JSON数组。
import ;
import ;
import ;
import ;
import ;
import ;
public class JacksonCreateJsonArrayExample {
// 示例POJO
static class User {
public String name;
public int age;
public String email;
public User(String name, int age, String email) {
= name;
= age;
= email;
}
// Jackson需要无参构造函数进行反序列化，但序列化时不是强制的
public User() {}
}
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
(SerializationFeature.INDENT_OUTPUT); // 启用美化输出
// 1. 从List<String>创建JSON数组
List<String> fruits = new ArrayList<>();
("apple");
("banana");
("orange");
String jsonArrayOfStrings = (fruits);
("JSON Array of Strings:" + jsonArrayOfStrings);
// 2. 从List<Map<String, Object>>创建JSON数组 (动态对象)
List<Map<String, Object>> peopleListMap = new ArrayList<>();
Map<String, Object> person1 = new HashMap<>();
("name", "Alice");
("age", 30);
(person1);
Map<String, Object> person2 = new HashMap<>();
("name", "Bob");
("age", 24);
(person2);
String jsonArrayOfMaps = (peopleListMap);
("JSON Array of Maps:" + jsonArrayOfMaps);
// 3. 从List<POJO>创建JSON数组 (推荐)
List<User> users = new ArrayList<>();
(new User("Charlie", 28, "charlie@"));
(new User("Diana", 35, "diana@"));
String jsonArrayOfPojos = (users);
("JSON Array of POJOs:" + jsonArrayOfPojos);
}
}

2. 树模型 (Tree Model)

当您不确定数据结构，或者需要动态构建复杂的JSON结构时，Jackson的树模型（`JsonNode`, `ArrayNode`, `ObjectNode`）非常有用。
import ;
import ;
import ;
import ;
import ;
public class JacksonTreeModelCreateJsonArrayExample {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
(SerializationFeature.INDENT_OUTPUT);
// 创建一个空的JSON数组
ArrayNode rootArray = ();
// 添加简单元素
("element1");
(123);
(true);
// 添加JSON对象到数组
ObjectNode user1 = ();
("name", "Eve");
("age", 29);
(user1);
// 添加另一个JSON数组到当前数组 (嵌套数组)
ArrayNode nestedArray = ();
(100);
(200);
(nestedArray);
String finalJson = (rootArray);
("JSON Array created with Tree Model:" + finalJson);
}
}

使用Gson库创建JSON数组

Gson是另一个非常流行的JSON库，以其简洁的API和对Java对象的良好支持而闻名。

1. 数据绑定 (POJO序列化)

与Jackson类似，Gson也能很方便地将Java集合序列化为JSON数组。
import ;
import ;
import ;
import ;
import ;
import ;
public class GsonCreateJsonArrayExample {
// 示例POJO
static class Product {
public String name;
public double price;
public boolean available;
public Product(String name, double price, boolean available) {
= name;
= price;
= available;
}
}
public static void main(String[] args) {
Gson gson = new GsonBuilder().setPrettyPrinting().create(); // 启用美化输出
// 1. 从List<String>创建JSON数组
List<String> colors = new ArrayList<>();
("red");
("green");
("blue");
String jsonArrayOfStrings = (colors);
("JSON Array of Strings:" + jsonArrayOfStrings);
// 2. 从List<Map<String, Object>>创建JSON数组
List<Map<String, Object>> itemAttributes = new ArrayList<>();
Map<String, Object> attr1 = new HashMap<>();
("size", "M");
("color", "Black");
(attr1);
String jsonArrayOfMaps = (itemAttributes);
("JSON Array of Maps:" + jsonArrayOfMaps);
// 3. 从List<POJO>创建JSON数组 (推荐)
List<Product> products = new ArrayList<>();
(new Product("Laptop", 1200.50, true));
(new Product("Mouse", 25.00, false));
String jsonArrayOfPojos = (products);
("JSON Array of POJOs:" + jsonArrayOfPojos);
}
}

2. 使用JsonArray (树模型/构建器)

Gson也提供了一个树模型，通过JsonArray和JsonObject来动态构建JSON结构。
import ;
import ;
import ;
import ;
public class GsonTreeModelCreateJsonArrayExample {
public static void main(String[] args) {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
// 创建一个空的JsonArray
JsonArray rootArray = new JsonArray();
// 添加基本类型元素
("task1");
(5);
(false);
// 添加JsonObject到数组
JsonObject taskDetails = new JsonObject();
("description", "Complete report");
("priority", "High");
(taskDetails);
// 添加嵌套JsonArray
JsonArray subTasks = new JsonArray();
("subtask A");
("subtask B");
(subTasks);
String finalJson = (rootArray);
("JSON Array created with Gson's JsonArray:" + finalJson);
}
}

使用库创建JSON数组

库是一个相对较老但仍然在一些项目中使用的库。它的API比较直接，但不如Jackson和Gson灵活，尤其是在处理POJO序列化方面。
import ;
import ;
import ;
import ;
public class OrgJsonCreateJsonArrayExample {
public static void main(String[] args) {
// 1. 创建一个简单的JSON数组并添加元素
JSONArray simpleArray = new JSONArray();
("itemA");
(10);
(true);
("Simple JSON Array:" + (4)); // toString(indentFactor) 用于美化输出
// 2. 创建一个包含JSON对象的数组
JSONArray usersArray = new JSONArray();
JSONObject user1 = new JSONObject();
("id", 1);
("name", "Frank");
(user1);
JSONObject user2 = new JSONObject();
("id", 2);
("name", "Grace");
(user2);
("JSON Array of Objects:" + (4));
// 3. 从Java集合（如List）创建JSONArray
List<String> cities = ("New York", "London", "Paris");
JSONArray citiesArray = new JSONArray(cities); // 可以直接从Collection构建
("JSON Array from List:" + (4));

// 也可以直接从Java数组或Collection创建，但对于POJO支持不佳，需要手动转换为JSONObject。
// 例如，如果有一个List，需要遍历List并为每个User手动创建JSONObject。
}
}

使用Jakarta JSON Processing (JSON-P) 库创建JSON数组

JSON-P提供了标准的JSON处理API，它有两个主要模型：流API（`JsonParser`, `JsonGenerator`）和对象模型（`JsonReader`, `JsonWriter`, `JsonStructure`, `JsonArray`, `JsonObject`）。在这里，我们主要使用对象模型来创建JSON数组。
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class JsonPCreateJsonArrayExample {
public static void main(String[] args) {
// 1. 使用()构建JSON数组
JsonArray simpleArray = ()
.add("valueA")
.add(123.45)
.add(true)
.build();
("Simple JSON-P Array:" + ());
// 2. 构建包含JSON对象的数组
JsonArray usersArray = ()
.add(()
.add("id", 101)
.add("username", "john_doe")
.build())
.add(()
.add("id", 102)
.add("username", "jane_smith")
.build())
.build();
("JSON-P Array of Objects:" + ());
// 3. 构建嵌套数组
JsonArray nestedArray = ()
.add("parent_item")
.add(() // 嵌套数组
.add("child_item_1")
.add("child_item_2")
.build())
.add(500)
.build();
("JSON-P Nested Array:" + ());
// 4. 美化输出 (需要使用JsonGenerator)
StringWriter stWriter = new StringWriter();
Map<String, Boolean> config = new HashMap<>();
(JsonGenerator.PRETTY_PRINTING, true);
writerFactory = (config);
jsonWriter = (stWriter);
(usersArray); // 写入需要美化的数组
();
("JSON-P Array of Objects (Pretty Print):" + ());
}
}

高级话题与最佳实践

1. 嵌套结构与复杂类型

无论是使用哪种库，都可以轻松创建复杂的嵌套JSON结构。例如，一个JSON数组中的每个元素又是一个包含其他JSON数组或JSON对象的复杂结构。使用POJO进行数据绑定时，只需在Java对象中定义对应的嵌套集合或自定义对象即可；使用树模型时，则通过链式调用`add`、`put`方法灵活构建。

2. 错误处理

在进行JSON序列化和反序列化时，可能会遇到各种异常，如`JsonProcessingException` (Jackson), `JsonSyntaxException` (Gson) 等。始终使用`try-catch`块来捕获和处理这些异常，确保程序的健壮性。
try {
// JSON操作
} catch ( e) {
("Jackson JSON processing error: " + ());
} catch ( e) {
("Gson JSON syntax error: " + ());
} catch (Exception e) {
("An unexpected error occurred: " + ());
}

3. 性能考量

大型JSON数组：对于非常大的JSON数组，一次性在内存中构建整个数组可能会消耗大量内存。在这些情况下，考虑使用流式API（如Jackson的`JsonGenerator`或JSON-P的流API）来逐个写入元素，而不是先构建完整的Java集合再序列化，或使用`InputStream`/`OutputStream`直接读写。
库选择：Jackson通常被认为是性能最好的JSON库之一，尤其是在高吞吐量场景下。Gson在性能上也表现良好，并且其简洁性在许多应用中是一个优势。

4. 可读性与美化输出

在开发和调试阶段，美化（Pretty Printing）JSON输出非常有用，可以使其更易于阅读和理解。如示例所示，Jackson的`SerializationFeature.INDENT_OUTPUT`、Gson的`GsonBuilder().setPrettyPrinting()`以及`(indentFactor)`都可以实现这一点。

5. 数据验证

在接收外部JSON数据时，对其进行验证是至关重要的。JSON Schema是定义JSON数据结构和内容的一种强大方式。虽然Java JSON库不直接提供JSON Schema验证，但有第三方库如`everit-json-schema`可以集成使用。

6. 选择合适的库

如果您需要极致的性能、丰富的功能、对注解的广泛支持以及与Spring等框架的深度集成，Jackson是您的首选。
如果您追求简洁、易用、快速将Java对象与JSON之间进行转换，并且对性能要求不是极端苛刻，Gson是非常好的选择。
如果您只需要非常简单的JSON构建和解析，并且希望依赖尽可能轻量，可能适用，但请注意其功能限制。
如果您正在开发Jakarta EE应用程序，并且希望使用平台提供的标准API，那么JSON-P是一个自然的集成点。

本文深入探讨了在Java中创建和操作JSON数组的多种方法，涵盖了Jackson、Gson、和JSON-P这四大主流库。无论是通过将Java集合序列化为JSON数组的数据绑定方式，还是通过树模型动态构建复杂结构，每个库都提供了灵活的API来满足不同的开发需求。

掌握这些技术对于任何Java开发者来说都是必不可少的。通过选择合适的工具，并遵循最佳实践，您可以有效地处理JSON数据，构建出高性能、健壮且易于维护的现代Java应用程序。

2025-11-10

上一篇：【深度解析】Java 8 默认方法：接口演进、多重继承与最佳实践

下一篇：Java中数组添加元素：理解固定大小限制与动态集合的替代方案