1. Overview
1.概述
Working with JSON (JavaScript Objеct Notation) in Java often involves using librariеs like Jackson, which provides various classеs to rеprеsеnt this type of data, such as JsonNodе, ObjectNode, and ArrayNode.
在 Java 中处理 JSON（JavaScript Objеct Notation）时，通常需要使用 Jackson 等库， 这些库提供了各种类来处理此类数据，例如 JsonNodе、ObjectNode、 和 ArrayNode。
In this tutorial, we’ll еxplorе different approaches to simplifying array operations on a JsonNodе without explicitly casting it to ArrayNode in Java. This is necessary when manipulating the data directly in our code.
在本教程中，我们将探索在JsonNodе上简化数组操作的不同方法，而无需在Java中将其显式转换为ArrayNode。在我们的代码中直接操作数据时，这是必要的。
2. Understanding JsonNode and ArrayNode
2.了解 JsonNode 和 ArrayNode
JsonNode is an abstract class in the Jackson library that represents a node in the JSON tree. It’s the base class for all nodes and is capable of storing different types of data, including objects, arrays, strings, numbers, booleans, and null values. JsonNode instances are immutable, meaning we can’t set properties on them.
JsonNode 是 Jackson 库中的一个抽象类，表示 JSON 树中的一个节点。它是所有节点的基类，能够存储不同类型的数据，包括对象、数组、字符串、数字、布尔值和空值。JsonNode实例是不可变的，这意味着我们无法对其设置属性。
ArrayNode is a specific type of JsonNode that represents a JSON array. It extends the functionality of JsonNode to include methods for working with arrays, such as adding, removing, and accessing elements by index.
ArrayNode 是 JsonNode 的一种特定类型，用于表示 JSON 数组。它扩展了JsonNode的功能，包括处理数组的方法，如添加、删除和按索引访问元素。
3. Using JsonNode‘s get() Method
3.使用 JsonNode 的 get() 方法
By using JsonNode methods, we can transform it to ArrayNode without explicitly casting. This approach is useful when we need to perform specific actions or validations on each element within a JSON array:
通过使用 JsonNode方法，我们可以将其转换为ArrayNode，而无需显式转换。当我们需要对 JSON 数组中的每个元素执行特定操作或验证时，这种方法非常有用：
@Test
void givenJsonNode_whenUsingJsonNodeMethods_thenConvertToArrayNode() throws JsonProcessingException {
int count = 0;
String json = "{\"objects\": [\"One\", \"Two\", \"Three\"]}";
JsonNode arrayNode = new ObjectMapper().readTree(json).get("objects");
assertNotNull(arrayNode, "The 'objects' array should not be null");
assertTrue(arrayNode.isArray(), "The 'objects' should be an array");
if (arrayNode.isArray()) {
for (JsonNode objNode : arrayNode) {
assertNotNull(objNode, "Array element should not be null");
count++;
}
}
assertEquals(3, count, "The 'objects' array should have 3 elements");
}This approach also ensures that we’re working with an array structure before attempting to iterate over its elements, helping prevent potential runtime errors related to unexpected JSON structures.
这种方法还能确保我们在尝试遍历数组元素之前处理的是数组结构，有助于防止与意外 JSON 结构相关的潜在运行时错误。
4. Using createArrayNode()
4.使用 createArrayNode()
In Jackson, we can create a JSON object using the createObjectNode() method. Similarly, we can use the createArrayNode() method of the ObjectMapper class to create a JSON Array. The method createArrayNode() will return a reference of ArrayNode class:
在 Jackson 中，我们可以使用 createObjectNode() 方法创建一个 JSON 对象。同样，我们可以使用 ObjectMapper 类的 createArrayNode() 方法创建一个 JSON 数组。方法 createArrayNode() 将返回 ArrayNode 类的引用：
@Test
void givenJsonNode_whenUsingCreateArrayNode_thenConvertToArrayNode() throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
JsonNode originalJsonNode = objectMapper.readTree("{\"objects\": [\"One\", \"Two\", \"Three\"]}");
ArrayNode arrayNode = objectMapper.createArrayNode();
originalJsonNode.get("objects").elements().forEachRemaining(arrayNode::add);
assertEquals("[\"One\",\"Two\",\"Three\"]", arrayNode.toString());
}This approach is useful when we need to transform a specific part of a JSON structure into an ArrayNode without explicitly casting. Creating an ArrayNode explicitly communicates that we’re working with an Array, making the code more readable and expressive.
当我们需要将 JSON 结构的特定部分转换为 ArrayNode 而无需显式转换时，这种方法非常有用。创建一个 ArrayNode 明确表明我们正在处理一个 数组，从而使代码更具可读性和表现力。
5. Using StreamSuppport Class
5.使用StreamSuppport类
StreamSupport is a utility class that provides static methods for creating Streams and Spliterators over various data structures, including collections, arrays, and specialized iterators. The string is deserialized into a JsonNode object using ObjectMapper. Here, we’re creating a Stream from the Spliterator of the objects array, and the elements are collected into the List<JsonNode>:
StreamSupport是一个实用程序类，它提供了静态方法，用于在各种数据结构（包括集合、数组和专用迭代器）上创建Streams和Spliterators。使用 ObjectMapper 将字符串反序列化为 JsonNode 对象。在这里，我们从 objects 数组的 Spliterator 创建一个 Stream ，并将元素收集到 List<JsonNode>: 中。
@Test
void givenJsonNode_whenUsingStreamSupport_thenConvertToArrayNode() throws Exception {
String json = "{\"objects\": [\"One\", \"Two\", \"Three\"]}";
JsonNode obj = new ObjectMapper().readTree(json);
List<JsonNode> objects = StreamSupport
.stream(obj.get("objects").spliterator(), false)
.collect(Collectors.toList());
assertEquals(3, objects.size(), "The 'objects' list should contain 3 elements");
JsonNode firstObject = objects.get(0);
assertEquals("One", firstObject.asText(), "The first element should be One");
}This approach is useful when we want to leverage Java Streams for a concise and expressive way to extract and process elements from a JSON array.
当我们想利用 Java Streams 以简洁而富有表现力的方式从 JSON 数组中提取和处理元素时，这种方法非常有用。
6. Using Iterator
6.使用迭代器</em
An Iterator is one of many ways we can traverse a collection. In this approach, we utilized an iterator to traverse the elements of the objects array in the given JSON structure:
Iterator 是我们遍历集合的众多方法之一。在这种方法中，我们使用迭代器来遍历给定 JSON 结构中 objects 数组的元素：
@Test
void givenJsonNode_whenUsingIterator_thenConvertToArrayNode() throws Exception {
String json = "{\"objects\": [\"One\", \"Two\", \"Three\"]}";
JsonNode datasets = new ObjectMapper().readTree(json);
Iterator<JsonNode> iterator = datasets.withArray("objects").elements();
int count = 0;
while (iterator.hasNext()) {
JsonNode dataset = iterator.next();
System.out.print(dataset.toString() + " ");
count++;
}
assertEquals(3, count, "The 'objects' list should contain 3 elements");
}This approach reduces the overall complexity by directly iterating through the elements. It provides a straightforward mechanism for customizing the processing of JSON elements during iteration.
这种方法通过直接迭代元素来降低整体复杂性。它为在迭代过程中自定义处理 JSON 元素提供了一种直接的机制。
7. Conclusion
7.结论
In this tutorial, we explored various approaches to simplifying array operations on JsonNode without explicitly typecasting it to ArrayNode in Jackson.
在本教程中，我们探索了各种方法来简化 JsonNode 上的数组操作，而无需在 Jackson 中将其明确类型化为 ArrayNode。
As always, the source code is available over on GitHub.
与往常一样，源代码可在 GitHub 上获取。