目前最主流的 JSON 库是 Jackson、Gson 和 org.json，下面我将分别介绍这三种库的使用方法，并给出完整的示例代码。

准备工作：添加 Maven 依赖

如果你使用 Maven，首先需要在你的 pom.xml 文件中添加相应库的依赖。

Jackson (推荐)

Jackson 是目前 Java 生态中最流行、性能最好的 JSON 库之一。

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

Google Gson

Gson 是 Google 提供的库，以其简洁易用而闻名。

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

org.json

这是一个比较轻量级的库,API 非常直接。

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

示例：将一个 Java 对象转换为 JSON 字符串

假设我们有一个简单的 User 类。

// User.java
public class User {
    private String name;
    private int age;
    private String[] hobbies;
    // 构造函数、Getter 和 Setter 方法是必须的
    public User() {}
    public User(String name, int age, String[] hobbies) {
        this.name = name;
        this.age = age;
        this.hobbies = hobbies;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String[] getHobbies() {
        return hobbies;
    }
    public void setHobbies(String[] hobbies) {
        this.hobbies = hobbies;
    }
    // 为了方便打印，可以重写 toString() 方法
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", hobbies=" + Arrays.toString(hobbies) +
                '}';
    }
}

使用 Jackson

Jackson 提供了 ObjectMapper 类，这是其核心 API。

关键点：

• ObjectMapper 是线程安全的，可以定义为静态常量重复使用。
• 默认情况下,Jackson 会忽略值为 null 的字段。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
    // 1. 创建 ObjectMapper 实例（推荐定义为 static final）
    private static final ObjectMapper objectMapper = new ObjectMapper();
    public static void main(String[] args) {
        User user = new User("张三", 30, new String[]{"阅读", "旅行", "编程"});
        try {
            // 2. 调用 writeValueAsString 方法进行转换
            String jsonString = objectMapper.writeValueAsString(user);
            // 3. 输出结果
            System.out.println("Jackson 转换结果:");
            System.out.println(jsonString);
            // 如果你想要格式化输出（美化），可以使用 writerWithDefaultPrettyPrinter()
            String prettyJsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
            System.out.println("\nJackson 美化输出结果:");
            System.out.println(prettyJsonString);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

输出结果:

Jackson 转换结果:
{"name":"张三","age":30,"hobbies":["阅读","旅行","编程"]}
Jackson 美化输出结果:
{
  "name" : "张三",
  "age" : 30,
  "hobbies" : [ "阅读", "旅行", "编程" ]
}

使用 Google Gson

Gson 的使用非常直观，通常只需要创建一个 Gson 实例并调用其 toJson() 方法。

关键点：

• Gson 实例也是线程安全的，可以重复使用。
• 默认情况下,Gson 也会忽略值为 null 的字段。

import com.google.gson.Gson;
public class GsonExample {
    // 1. 创建 Gson 实例（推荐定义为 static final）
    private static final Gson gson = new Gson();
    public static void main(String[] args) {
        User user = new User("李四", 25, new String[]{"音乐", "电影"});
        // 2. 调用 toJson 方法进行转换
        String jsonString = gson.toJson(user);
        // 3. 输出结果
        System.out.println("Gson 转换结果:");
        System.out.println(jsonString);
        // Gson 默认不提供内置的美化输出，但可以通过 GsonBuilder 实现
        // Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
        // String prettyJsonString = prettyGson.toJson(user);
        // System.out.println(prettyJsonString);
    }
}

输出结果:

Gson 转换结果:
{"name":"李四","age":25,"hobbies":["音乐","电影"]}

使用 org.json

这个库的 API 风格略有不同，你需要先创建一个 JSONObject 或 JSONArray 对象，然后调用其 toString() 方法。

关键点：

• 它不直接作用于你的 Java 对象，而是需要你手动将 Java 对象的值put到 JSONObject 中。

import org.json.JSONObject;
import java.util.HashMap;
import java.util.Map;
public class OrgJsonExample {
    public static void main(String[] args) {
        // 1. 创建一个 JSONObject 实例
        JSONObject jsonObject = new JSONObject();
        // 2. 使用 put 方法将数据添加到 JSONObject 中
        jsonObject.put("name", "王五");
        jsonObject.put("age", 28);
        // 处理数组或集合
        jsonObject.put("hobbies", new String[]{"游戏", "运动"});
        // 也可以直接 put 一个 Map
        Map<String, Object> data = new HashMap<>();
        data.put("city", "北京");
        data.put("zipCode", 100000);
        jsonObject.put("address", data);
        // 3. 调用 toString() 方法
        String jsonString = jsonObject.toString();
        // 4. 输出结果
        System.out.println("org.json 转换结果:");
        System.out.println(jsonString);
        // org.json 同样不提供内置的美化输出，需要手动处理或使用其他工具。
    }
}

输出结果:

org.json 转换结果:
{"name":"王五","age":28,"hobbies":["游戏","运动"],"address":{"city":"北京","zipCode":100000}}

总结与对比

对于绝大多数 Java 项目，Jackson 是最佳选择，因为它功能全面、性能卓越，并且是许多框架（如 Spring Boot）的默认实现。

如果你只需要快速、简单地完成 JSON 转换，并且项目没有特殊要求，Gson 是一个非常好的备选。

org.json 则适合那些只需要基础 JSON 功能，并且不希望引入过多依赖的轻量级场景。