处理嵌套映射并保持结构不变地过滤数据-java教程-PHP中文网

处理嵌套映射并保持结构不变地过滤数据

本文详细探讨了在Java中处理嵌套JSON数据并进行过滤的策略，特别关注如何在使用Jackson库将JSON解析为Map<?, ?>时，在不破坏外部结构的前提下，准确地过滤深层数据。文章将介绍泛型类型擦除带来的挑战，提供基于流的解决方案，并进一步展示如何利用Jackson的JsonNode API实现更健壮和类型安全的过滤机制，确保数据处理的准确性和代码的可维护性。

1. 引言：嵌套JSON数据过滤的挑战

在现代应用开发中，处理嵌套的JSON数据是常见的任务。当我们需要从复杂的JSON结构中提取或过滤特定信息，同时又希望保留其原始的层次结构时，会面临一些挑战。例如，从一个包含多层电影分类的JSON文件中，筛选出所有“热门”电影，并保持其所属的类型和国家分类不变。

考虑以下电影数据的JSON结构：

{
    "Bollywood": {
        "Romance": {
            "hit": false,
            "name": "Prithvi Raj"
        },
        "Action": {
            "hit": true,
            "name": "3 Idiots"
        }
    },
    "Hollywood": {
        "Romance": {
            "hit": false,
            "name": "Intimacy"
        },
        "Action": {
            "hit": true,
            "name": "Seven Samurai"
        }
    }
}

登录后复制

我们的目标是过滤掉所有"hit": false的电影，最终得到如下结构：

{
    "Bollywood": {
        "Action": {
            "hit": true,
            "name": "3 Idiots"
        }
    },
    "Hollywood": {
        "Action": {
            "hit": true,
            "name": "Seven Samurai"
        }
    }
}

登录后复制

使用Jackson库将JSON文件解析为Java的Map对象是常见的做法。然而，当使用像Map<?, ?>这样的不确定泛型类型时，深入嵌套结构进行操作会遇到类型安全问题。

2. 问题分析：Map<?, ?>与类型擦除

当Jackson将JSON解析为Map.class时，通常会得到一个Map<String, Object>的实例。但如果声明为Map<?, ?>，则其键和值都被视为java.lang.Object类型。这意味着在尝试访问其内部结构（例如调用entrySet()方法）时，编译器无法确定Object类型是否拥有这些方法，从而导致编译错误，例如：

error: cannot find symbol
                           .entrySet()
                           ^
  symbol:   method entrySet()
  location: class Object

登录后复制

这是因为Java的泛型在运行时会被擦除，Map<?, ?>在运行时实际上是Map<Object, Object>。要解决这个问题，我们需要在访问嵌套结构时进行显式的类型转换（Casting）。

AI Sofiya

一款AI驱动的多功能工具

109

查看详情

3. 解决方案一：通过显式类型转换进行流式过滤

为了在不破坏外部Map结构的情况下过滤嵌套数据，我们需要对每一层进行适当的类型转换，以便可以调用相应的方法（如entrySet()）并访问内部属性。

以下是使用Java Stream API和显式类型转换实现过滤的示例代码：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.nio.file.Paths;
import java.util.Map;
import java.util.stream.Collectors;

public class JsonMovieFilter {

    public static void main(String[] args) {
        try {
            // 确保 movie.json 文件存在于项目根目录或指定路径
            // 创建一个示例 movie.json 文件
            String jsonContent = "{\n" +
                    "    \"Bollywood\": {\n" +
                    "        \"Romance\": {\n" +
                    "            \"hit\": false,\n" +
                    "            \"name\": \"Prithvi Raj\"\n" +
                    "        },\n" +
                    "        \"Action\": {\n" +
                    "            \"hit\": true,\n" +
                    "            \"name\": \"3 Idiots\"\n" +
                    "        }\n" +
                    "    },\n" +
                    "\n" +
                    "\"Hollywood\": {\n" +
                    "        \"Romance\": {\n" +
                    "            \"hit\": false,\n" +
                    "            \"name\": \"Intimacy\"\n" +
                    "        },\n" +
                    "        \"Action\": {\n" +
                    "            \"hit\": true,\n" +
                    "            \"name\": \"Seven Samurai\"\n" +
                    "        }\n" +
                    "    }\n" +
                    "}";

            // 将JSON内容写入文件，以便ObjectMapper读取
            // Files.write(Paths.get("movie.json"), jsonContent.getBytes()); // 如果需要实际创建文件

            ObjectMapper mapper = new ObjectMapper();
            // 直接从字符串读取，避免文件IO，方便测试
            Map<String, Object> originalMap = mapper.readValue(jsonContent, Map.class);

            // 使用Stream API进行嵌套过滤
            Map<String, Map<String, Object>> filteredMap = originalMap.entrySet().stream()
                .collect(Collectors.toMap(
                    Map.Entry::getKey, // 保留顶层键 (e.g., "Bollywood", "Hollywood")
                    entry -> {
                        // 将顶层值（Object类型）强制转换为 Map<String, Object>
                        Map<String, Object> innerGenreMap = (Map<String, Object>) entry.getValue();

                        // 对内层Map进行过滤
                        Map<String, Object> filteredGenreMap = innerGenreMap.entrySet().stream()
                            .filter(subEntry -> {
                                // 将内层值（Object类型，即电影详情Map）强制转换为 Map<String, Object>
                                Map<String, Object> movieDetails = (Map<String, Object>) subEntry.getValue();
                                // 检查 "hit" 属性是否存在且为 true
                                return Boolean.TRUE.equals(movieDetails.get("hit"));
                            })
                            .collect(Collectors.toMap(
                                Map.Entry::getKey, // 保留电影类型键 (e.g., "Action")
                                Map.Entry::getValue // 保留过滤后的电影详情Map
                            ));
                        return filteredGenreMap;
                    }
                ))
                // 过滤掉所有值为空Map的顶层条目 (即没有热门电影的分类)
                .entrySet().stream()
                .filter(entry -> !((Map<String, Object>) entry.getValue()).isEmpty())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));


            // 打印过滤后的结果
            System.out.println("Filtered Map:\n" + mapper.writerWithDefaultPrettyPrinter().writeValueAsString(filteredMap));

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

登录后复制

代码解释：

originalMap.entrySet().stream(): 获取顶层Map的键值对流，例如 ("Bollywood", {...})。
外层 Collectors.toMap: 用于构建新的顶层Map。
- Map.Entry::getKey: 直接使用原始的顶层键（如 "Bollywood"）。
- entry -> {...}: 对每个顶层值（即{"Romance": {...}, "Action": {...}}这个Map）进行处理。
Map<String, Object> innerGenreMap = (Map<String, Object>) entry.getValue();: 这里是关键。由于entry.getValue()的类型是Object，我们必须将其强制转换为Map<String, Object>才能调用其entrySet()方法。
innerGenreMap.entrySet().stream(): 获取内层Map的键值对流，例如 ("Romance", {"hit": false, ...})。
filter(subEntry -> {...}): 对内层流进行过滤。
- Map<String, Object> movieDetails = (Map<String, Object>) subEntry.getValue();: 再次进行类型转换，将电影详情（Object类型）转换为Map<String, Object>。
- Boolean.TRUE.equals(movieDetails.get("hit")): 检查电影详情Map中"hit"键的值是否为true。使用Boolean.TRUE.equals()可以避免NullPointerException，即使get("hit")返回null也不会报错。
内层 Collectors.toMap: 构建过滤后的内层Map，只包含符合条件的电影条目。
后续过滤 (.entrySet().stream().filter(...)): 在外层Collectors.toMap完成后，我们可能得到一些空的内层Map（例如，某个电影分类下没有热门电影）。这一步用于移除这些空的分类，使最终输出更整洁。

注意事项： 这种基于Map<?, ?>和显式类型转换的方法虽然可以工作，但在处理更复杂或结构不确定的JSON时，会变得繁琐且容易出错。每次访问深层数据都需要进行类型转换，如果类型不匹配，会在运行时抛出ClassCastException。

4. 解决方案二：利用Jackson JsonNode API 实现健壮过滤

Jackson库提供了JsonNode API，它提供了一种更健壮、类型安全的方式来遍历和操作JSON数据，而无需频繁进行Java类型转换。JsonNode代表JSON结构中的一个节点，可以轻松地访问其子节点、属性和值。

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.io.File;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.Map;

public class JsonMovieFilterWithJsonNode {

    public static void main(String[] args) {
        try {
            String jsonContent = "{\n" +
                    "    \"Bollywood\": {\n" +
                    "        \"Romance\": {\n" +
                    "            \"hit\": false,\n" +
                    "            \"name\": \"Prithvi Raj\"\n" +
                    "        },\n" +
                    "        \"Action\": {\n" +
                    "            \"hit\": true,\n" +
                    "            \"name\": \"3 Idiots\"\n" +
                    "        }\n" +
                    "    },\n" +
                    "\n" +
                    "\"Hollywood\": {\n" +
                    "        \"Romance\": {\n" +
                    "            \"hit\": false,\n" +
                    "            \"name\": \"Intimacy\"\n" +
                    "        },\n" +
                    "        \"Action\": {\n" +
                    "            \"hit\": true,\n" +
                    "            \"name\": \"Seven Samurai\"\n" +
                    "        }\n" +
                    "    }\n" +
                    "}";

            ObjectMapper mapper = new ObjectMapper();
            // 将JSON字符串解析为JsonNode
            JsonNode rootNode = mapper.readTree(jsonContent);

            // 创建一个用于存储过滤结果的ObjectNode
            ObjectNode filteredRoot = mapper.createObjectNode();

            // 遍历顶层节点 (e.g., "Bollywood", "Hollywood")
            Iterator<Map.Entry<String, JsonNode>> genres = rootNode.fields();
            while (genres.hasNext()) {
                Map.Entry<String, JsonNode> genreEntry = genres.next();
                String genreKey = genreEntry.getKey();
                JsonNode genreNode = genreEntry.getValue(); // e.g., {"Romance": {...}, "Action": {...}}

                ObjectNode filteredGenre = mapper.createObjectNode();

                // 遍历电影类型节点 (e.g., "Romance", "Action")
                Iterator<Map.Entry<String, JsonNode>> movieTypes = genreNode.fields();
                while (movieTypes.hasNext()) {
                    Map.Entry<String, JsonNode> movieTypeEntry = movieTypes.next();
                    String movieTypeKey = movieTypeEntry.getKey();
                    JsonNode movieDetailsNode = movieTypeEntry.getValue(); // e.g., {"hit": false, "name": "Prithvi Raj"}

                    // 检查 "hit" 属性是否存在且为 true
                    if (movieDetailsNode.has("hit") && movieDetailsNode.get("hit").asBoolean()) {
                        filteredGenre.set(movieTypeKey, movieDetailsNode);
                    }
                }

                // 如果该电影分类下有热门电影，则添加到结果中
                if (filteredGenre.size() > 0) {
                    filteredRoot.set(genreKey, filteredGenre);
                }
            }

            // 打印过滤后的结果
            System.out.println("Filtered JsonNode:\n" + mapper.writerWithDefaultPrettyPrinter().writeValueAsString(filteredRoot));

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

登录后复制

代码解释：

mapper.readTree(jsonContent): 将JSON内容直接解析为JsonNode对象，这是一个树形结构，代表了整个JSON。
mapper.createObjectNode(): 创建一个新的ObjectNode（JsonNode的子类，代表JSON对象），用于构建过滤后的结果。
rootNode.fields(): 获取顶层JSON对象的所有字段（键值对）的迭代器。每个值都是一个JsonNode。
genreNode.fields(): 同样地，获取每个电影分类（如 "Bollywood"）下的所有电影类型字段的迭代器。
movieDetailsNode.has("hit"): 安全地检查当前电影详情节点是否包含名为"hit"的字段。
movieDetailsNode.get("hit").asBoolean(): 获取"hit"字段的值并将其转换为布尔类型。JsonNode提供了asBoolean(), asText(), asInt()等方法，可以安全地获取不同类型的值，如果节点不存在或类型不匹配，通常会返回默认值（如false、null、0），而不是抛出异常。
filteredGenre.set(movieTypeKey, movieDetailsNode): 如果电影符合过滤条件，将其添加到构建中的filteredGenre ObjectNode中。
filteredRoot.set(genreKey, filteredGenre): 如果某个电影分类下有符合条件的电影，则将其添加到最终的filteredRoot ObjectNode中。

5. 最佳实践与考量

类型安全与可读性: JsonNode方法通常比Map<?, ?>加大量类型转换更具类型安全性和可读性，尤其是在处理深层嵌套结构时。它避免了运行时ClassCastException的风险。
性能: 对于非常大的JSON文件，Jackson还提供了Streaming API (JsonParser, JsonGenerator)，可以逐个令牌地

以上就是处理嵌套映射并保持结构不变地过滤数据的详细内容，更多请关注php中文网其它相关文章！