使用 Jackson (推荐)

Jackson 是目前 Java 生态中最流行、性能最高的 JSON 处理库之一，Spring Boot 等主流框架都内置了它。

添加 Maven 依赖

在你的 pom.xml 文件中添加 Jackson 的核心依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version> <!-- 建议使用最新版本 -->
</dependency>

核心代码示例

Jackson 提供了一个 ObjectMapper 类,它是所有操作的入口。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;
public class MapToJsonWithJackson {
    public static void main(String[] args) {
        // 1. 创建一个 Map
        // Map 的键必须是 String 类型，值可以是任意 Java 对象
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("name", "张三");
        dataMap.put("age", 30);
        dataMap.put("isStudent", false);
        dataMap.put("courses", new String[]{"语文", "数学", "英语"});
        // 添加一个嵌套的 Map
        Map<String, String> address = new HashMap<>();
        address.put("city", "北京");
        address.put("district", "海淀区");
        dataMap.put("address", address);
        // 2. 创建 ObjectMapper 实例
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 3. 使用 writeValueAsString 方法将 Map 转换为 JSON 字符串
            // 这个方法会自动处理复杂对象和嵌套结构
            String jsonString = objectMapper.writeValueAsString(dataMap);
            // 4. 输出结果
            System.out.println("使用 Jackson 转换后的 JSON:");
            System.out.println(jsonString);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

输出结果

上述代码的输出结果如下（格式可能因版本略有不同，但内容一致）：

{
  "name" : "张三",
  "age" : 30,
  "isStudent" : false,
  "courses" : [ "语文", "数学", "英语" ],
  "address" : {
    "city" : "北京",
    "district" : "海淀区"
  }
}

Jackson 的优点

• 高性能：解析和生成速度非常快。
• 功能强大：支持复杂的 JSON 数据结构、注解、数据绑定等。
• 生态完善：是 Spring 等框架的默认选择,社区支持好。
• 灵活性高：可以通过 ObjectMapper 进行各种配置，如日期格式、空值处理等。

使用 Gson

Google 的 Gson 是另一个非常流行的 JSON 库,以其简洁易用而著称。

添加 Maven 依赖

在 pom.xml 文件中添加 Gson 依赖：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version> <!-- 建议使用最新版本 -->
</dependency>

核心代码示例

Gson 的使用也非常简单，直接创建 Gson 实例并调用其 toJson 方法。

import com.google.gson.Gson;
import java.util.HashMap;
import java.util.Map;
public class MapToJsonWithGson {
    public static void main(String[] args) {
        // 1. 创建一个 Map (与 Jackson 示例中的 Map 相同)
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("name", "李四");
        dataMap.put("age", 25);
        dataMap.put("isStudent", true);
        dataMap.put("courses", new String[]{"物理", "化学"});
        Map<String, String> address = new HashMap<>();
        address.put("city", "上海");
        address.put("district", "浦东新区");
        dataMap.put("address", address);
        // 2. 创建 Gson 实例
        Gson gson = new Gson();
        // 3. 使用 toJson 方法将 Map 转换为 JSON 字符串
        String jsonString = gson.toJson(dataMap);
        // 4. 输出结果
        System.out.println("使用 Gson 转换后的 JSON:");
        System.out.println(jsonString);
    }
}

输出结果

{"name":"李四","age":25,"isStudent":true,"courses":["物理","化学"],"address":{"city":"上海","district":"浦东新区"}}

注意：默认情况下，Gson 输出的 JSON 是紧凑格式的（没有多余的空格和换行），如果需要美化输出，可以创建 Gson 时使用 new GsonBuilder().setPrettyPrinting().create()。

Gson 的优点

• API 简单直观：学习成本低,上手快。
• 无需依赖：除了自身库外,没有其他外部依赖。
• Google 背书：稳定可靠,广泛应用于各种项目中。

使用 org.json (标准库，不推荐用于复杂场景)

Java EE 9+ 和 Jakarta EE 8+ 中引入了标准的 javax.json 包（或 jakarta.json），如果你使用的是较新的 Java 版本并且不想引入第三方库，可以考虑它，但它的 API 相对繁琐。

注意：这个库通常需要单独引入，因为它不是 JSE 的核心部分。

添加 Maven 依赖

<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>jakarta.json</artifactId>
    <version>2.0.1</version>
</dependency>

核心代码示例

import jakarta.json.Json;
import jakarta.json.JsonObject;
import jakarta.json.JsonObjectBuilder;
import java.util.HashMap;
import java.util.Map;
public class MapToJsonWithOrgJson {
    public static void main(String[] args) {
        // 1. 创建一个 Map
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("name", "王五");
        dataMap.put("age", 40);
        // 2. 创建一个 JsonObjectBuilder
        JsonObjectBuilder builder = Json.createObjectBuilder();
        // 3. 遍历 Map，将每个键值对添加到 builder 中
        // 注意：对于复杂对象，需要手动创建对应的 JSON 结构
        for (Map.Entry<String, Object> entry : dataMap.entrySet()) {
            if (entry.getValue() instanceof String) {
                builder.add(entry.getKey(), (String) entry.getValue());
            } else if (entry.getValue() instanceof Integer) {
                builder.add(entry.getKey(), (Integer) entry.getValue());
            }
            // ... 需要为其他类型添加 else if 分支
        }
        // 4. 构建 JsonObject
        JsonObject jsonObject = builder.build();
        // 5. 将 JsonObject 转换为字符串
        String jsonString = jsonObject.toString();
        // 6. 输出结果
        System.out.println("使用 org.json 转换后的 JSON:");
        System.out.println(jsonString);
    }
}

输出结果

{"name":"王五","age":40}

org.json 的缺点

• API 繁琐：需要手动处理各种数据类型,对于嵌套对象和集合非常麻烦。
• 功能有限：相比 Jackson 和 Gson,功能较少。
• 性能一般：通常不如 Jackson 和 Gson。

总结与对比

最终建议：

• 新项目：直接选择 Jackson，它是事实上的行业标准，功能、性能和生态都是最好的。
• 快速原型或小型项目：Gson 是一个非常好的选择，简单易用,能满足大部分需求。
• 避免使用：除非有特殊限制，否则尽量避免使用 org.json 来处理复杂的 JSON 转换。