核心思想

将 Java Map 转换为 JSON，本质上是将 Java 的键值对结构序列化（Serialize）成 JSON 的键值对结构（{ "key": "value" }）。 将 JSON 转换为 Java Map，则是反序列化（Deserialize）的过程。

使用 Jackson (推荐)

Jackson 是目前 Java 生态中最流行、功能最强大的 JSON 处理库，Spring Boot 等主流框架都默认集成了它。

添加依赖

如果你使用 Maven，在 pom.xml 中添加：

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

如果你使用 Gradle，在 build.gradle 中添加：

implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2' // 使用最新稳定版本

代码示例

Jackson 的核心类是 ObjectMapper。

Map 转 JSON (JSON 字符串)

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. 创建 ObjectMapper 实例（推荐全局单例）
        ObjectMapper objectMapper = new ObjectMapper();
        // 2. 创建一个 Map
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("name", "张三");
        dataMap.put("age", 30);
        dataMap.put("isStudent", false);
        dataMap.put("courses", new String[]{"语文", "数学", "英语"});
        // 3. 将 Map 转换为 JSON 字符串
        try {
            // 默认情况下，objectMapper.writeValueAsString() 会输出紧凑的 JSON
            String jsonString = objectMapper.writeValueAsString(dataMap);
            System.out.println("紧凑的 JSON:");
            System.out.println(jsonString);
            // 如果需要格式化输出（美化），使用 enable 方法
            String prettyJsonString = objectMapper.enable(SerializationFeature.INDENT_OUTPUT).writeValueAsString(dataMap);
            System.out.println("\n格式化的 JSON:");
            System.out.println(prettyJsonString);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

紧凑的 JSON:
{"name":"张三","age":30,"isStudent":false,"courses":["语文","数学","英语"]}
格式化的 JSON:
{
  "name" : "张三",
  "age" : 30,
  "isStudent" : false,
  "courses" : [ "语文", "数学", "英语" ]
}

JSON 转 Map

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
public class JsonToMapWithJackson {
    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonString = "{\"name\":\"李四\",\"age\":25,\"city\":\"北京\"}";
        try {
            // 使用 TypeReference 来明确指定要转换的目标类型是 Map<String, Object>
            // 如果不使用 TypeReference，可能会因为类型擦除而转换失败
            Map<String, Object> dataMap = objectMapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
            // 打印 Map
            dataMap.forEach((key, value) -> {
                System.out.println(key + ": " + value + " (类型: " + value.getClass().getSimpleName() + ")");
            });
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

name: 李四 (类型: String)
age: 25 (类型: Integer)
city: 北京 (类型: String)

Map 转 JSON 对象 (如 JSONObject)

如果你需要的是 org.json.JSONObject 而不是字符串,可以这样做：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.json.JSONObject; // 需要额外引入 org.json 库
import java.util.Map;
public class MapToJsonObject {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, Object> map = Map.of("key", "value", "number", 123);
        // 1. 先将 Map 转为 JSON 字符串
        String jsonString = objectMapper.writeValueAsString(map);
        // 2. 再将 JSON 字符串转为 JSONObject
        JSONObject jsonObject = new JSONObject(jsonString);
        System.out.println(jsonObject);
        System.out.println(jsonObject.getString("key"));
    }
}

使用 Gson

Google 的 Gson 是另一个非常受欢迎的 JSON 库,以其简洁易用而闻名。

添加依赖

Maven:

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

Gradle:

implementation 'com.google.code.gson:gson:2.10.1' // 使用最新稳定版本

代码示例

Gson 的核心类是 Gson。

Map 转 JSON

import com.google.gson.Gson;
import java.util.HashMap;
import java.util.Map;
public class MapToJsonWithGson {
    public static void main(String[] args) {
        // 1. 创建 Gson 实例
        Gson gson = new Gson();
        // 2. 创建 Map
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("name", "王五");
        dataMap.put("age", 40);
        dataMap.put("skills", Map.of("java", "expert", "python", "intermediate"));
        // 3. 转换为 JSON 字符串 (Gson 默认不提供美化输出，需要手动处理或使用 new GsonBuilder().setPrettyPrinting().create())
        String jsonString = gson.toJson(dataMap);
        System.out.println(jsonString);
    }
}

输出结果：

{"name":"王五","age":40,"skills":{"java":"expert","python":"intermediate"}}

JSON 转 Map

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.Map;
public class JsonToMapWithGson {
    public static void main(String[] args) {
        Gson gson = new Gson();
        String jsonString = "{\"brand\":\"Tesla\",\"model\":\"Model 3\"}";
        // 1. 创建 TypeToken 来指定目标类型
        Type type = new TypeToken<Map<String, Object>>() {}.getType();
        // 2. 转换为 Map
        Map<String, Object> dataMap = gson.fromJson(jsonString, type);
        // 打印 Map
        dataMap.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

输出结果：

brand: Tesla
model: Model 3

使用 org.json (简单直接)

org.json 是一个轻量级的库，API 非常直观。

添加依赖

Maven:

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20251013</version> <!-- 使用最新稳定版本 -->
</dependency>

Gradle:

implementation 'org.json:json:20251013' // 使用最新稳定版本

代码示例

Map 转 JSONObject

import org.json.JSONObject;
import java.util.HashMap;
import java.util.Map;
public class MapToOrgJson {
    public static void main(String[] args) {
        // 1. 创建 Map
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("id", 101);
        dataMap.put("active", true);
        // 2. 直接用 Map 的构造函数创建 JSONObject
        JSONObject jsonObject = new JSONObject(dataMap);
        // 3. JSONObject 可以直接转换为字符串
        System.out.println(jsonObject.toString(2)); // 参数 2 表示缩进2个空格，用于美化输出
    }
}

输出结果：

{
  "id": 101,
  "active": true
}

JSONObject 转 Map

org.json 库本身没有直接提供 JSONObject 到 Map 的转换方法,需要手动遍历实现。

import org.json.JSONObject;
import java.util.HashMap;
import java.util.Map;
public class OrgJsonToMap {
    public static void main(String[] args) {
        String jsonString = "{\"username\":\"admin\",\"password\":\"secret\"}";
        JSONObject jsonObject = new JSONObject(jsonString);
        // 手动转换
        Map<String, Object> map = new HashMap<>();
        for (String key : jsonObject.keySet()) {
            map.put(key, jsonObject.get(key));
        }
        // 打印 Map
        System.out.println(map);
    }
}

输出结果：

{username=admin, password=secret}

总结与对比

最终建议

• 如果你正在使用 Spring Boot 或进行任何企业级开发，毫无疑问选择 Jackson，它是事实上的标准，与 Spring 生态无缝集成,功能强大且性能卓越。
• 如果你在做一个独立的小项目，或者只是需要一个简单、可靠的 JSON 库，Gson 是一个绝佳的选择，它的 API 设计非常友好,学习成本低。
• 如果你的项目对依赖大小有极其严苛的要求，处理的 JSON 结构非常简单，可以考虑 org.json，但对于大多数情况,它的功能可能略显不足。