1. Java 对象 (Object) -> JSONObject
2. JSONObject -> Java 对象 (Object)
3. JSONObject -> JSON 字符串 (String)
4. JSON 字符串 (String) -> JSONObject

下面我将分点详细介绍,并提供完整的代码示例。

准备工作：添加依赖

你需要确保你的项目中包含了 org.json 库，如果你使用 Maven，在 pom.xml 中添加以下依赖：

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

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

implementation 'org.json:json:20251013' // 建议使用最新版本

Java 对象 -> JSONObject

将一个普通的 Java 对象（POJO - Plain Old Java Object）转换为 JSONObject，最直接的方法是使用 JSONObject 的构造函数。

示例：

假设我们有一个 User 类：

// User.java
public class User {
    private String name;
    private int age;
    private boolean isActive;
    // 必须提供一个无参构造函数，以便 JSONObject 反射创建实例
    public User() {
    }
    public User(String name, int age, boolean isActive) {
        this.name = name;
        this.age = age;
        this.isActive = isActive;
    }
    // 为方便打印和查看，重写 toString() 方法
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", isActive=" + isActive +
                '}';
    }
    // Getter 和 Setter 方法（JSONObject 反射时需要）
    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 boolean isActive() { return isActive; }
    public void setActive(boolean active) { isActive = active; }
}

我们将 User 对象转换为 JSONObject：

import org.json.JSONObject;
import java.util.HashMap;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        // 1. 从 Java 对象创建 JSONObject
        User user = new User("Alice", 30, true);
        JSONObject userJsonObject = new JSONObject(user);
        System.out.println("从 User 对象创建的 JSONObject:");
        System.out.println(userJsonObject.toString());
        // 输出: {"name":"Alice","age":30,"isActive":true}
    }
}

工作原理： JSONObject 的构造函数会使用 Java 的反射机制，遍历目标对象的所有 public 的字段（或通过 getter 方法获取的值），并将它们以键值对的形式存入 JSONObject。

JSONObject -> Java 对象

将 JSONObject 转换回 Java 对象，主要有两种方式。

使用 JSONObject.toBean() (不推荐，已过时)

org.json 库早期版本提供了一个 toBean() 方法，但该方法已被标记为过时 (@Deprecated)，因为它在处理复杂类型（如嵌套对象、集合）时能力有限，且容易出错。

示例（仅作了解）：

// User.java (同上)
// JSONObject userJsonObject = ...; // 假设已经有一个 JSONObject
// 过时且不推荐的方式
// User userFromJson = (User) userJsonObject.toBean(User.class);

请避免使用此方法。

手动解析（推荐，灵活且健壮）

这是最常用、最可靠的方法，你通过 JSONObject 提供的 getXXX() 系列方法（如 getString(), getInt(), getBoolean() 等）来获取每个字段的值，然后手动赋给一个 Java 对象。

示例：

import org.json.JSONObject;
public class Main {
    public static void main(String[] args) {
        // 假设这是从某个地方获取的 JSON 字符串
        String jsonString = "{\"name\":\"Bob\",\"age\":25,\"isActive\":false}";
        JSONObject userJsonObject = new JSONObject(jsonString);
        // 手动解析 JSONObject 到 User 对象
        User userFromJson = new User();
        userFromJson.setName(userJsonObject.getString("name"));
        userFromJson.setAge(userJsonObject.getInt("age"));
        userFromJson.setActive(userJsonObject.getBoolean("isActive"));
        System.out.println("\n从 JSONObject 手动解析回的 User 对象:");
        System.out.println(userFromJson.toString());
        // 输出: User{name='Bob', age=25, isActive=false}
    }
}

优点：

• 完全可控：你可以精确地处理每个字段，包括类型转换和错误处理。
• 健壮性高：可以轻松处理嵌套对象和复杂的 JSON 结构。
• 性能较好：避免了反射带来的额外开销。

JSONObject -> JSON 字符串 (String)

将 JSONObject 转换为格式化的 JSON 字符串非常简单，直接调用 toString() 方法即可。

示例：

import org.json.JSONObject;
public class Main {
    public static void main(String[] args) {
        // 创建一个 JSONObject
        JSONObject data = new JSONObject();
        data.put("city", "Beijing");
        data.put("country", "China");
        data.put("population", 21540000);
        // 转换为 JSON 字符串
        String jsonString = data.toString();
        System.out.println("\nJSONObject 转换为 JSON 字符串:");
        System.out.println(jsonString);
        // 输出: {"city":"Beijing","country":"China","population":21540000}
    }
}

格式化输出（美化）： 如果你希望输出的 JSON 字符串是缩进、易读的格式，可以使用 toString(int indent) 方法。

String prettyJsonString = data.toString(2); // indent 参数指定缩进空格数
System.out.println("\n格式化后的 JSON 字符串:");
System.out.println(prettyJsonString);
/*
输出:
{
  "city": "Beijing",
  "country": "China",
  "population": 21540000
}
*/

JSON 字符串 (String) -> JSONObject

从一个标准的 JSON 格式的字符串创建 JSONObject，直接使用 JSONObject 的构造函数即可。

示例：

import org.json.JSONObject;
public class Main {
    public static void main(String[] args) {
        // 一个 JSON 格式的字符串
        String jsonString = "{\"productId\":101,\"productName\":\"Laptop\",\"price\":1200.99}";
        // 从字符串创建 JSONObject
        JSONObject productJsonObject = new JSONObject(jsonString);
        System.out.println("\n从 JSON 字符串创建的 JSONObject:");
        System.out.println(productJsonObject);
        // 现在可以像操作普通对象一样访问它的数据
        int id = productJsonObject.getInt("productId");
        String name = productJsonObject.getString("productName");
        double price = productJsonObject.getDouble("price");
        System.out.println("\n解析出的数据:");
        System.out.println("ID: " + id);
        System.out.println("Name: " + name);
        System.out.println("Price: " + price);
    }
}

处理复杂的嵌套 JSON 结构

在实际应用中,JSON 结构往往更复杂，包含嵌套的对象和数组。

示例 JSON:

{
  "id": "12345",
  "user": {
    "name": "Charlie",
    "contact": {
      "email": "charlie@example.com",
      "phone": "123-456-7890"
    }
  },
  "tags": ["java", "json", "api"]
}

解析代码：

import org.json.JSONObject;
public class Main {
    public static void main(String[] args) {
        String complexJsonString = "{\n" +
                "  \"id\": \"12345\",\n" +
                "  \"user\": {\n" +
                "    \"name\": \"Charlie\",\n" +
                "    \"contact\": {\n" +
                "      \"email\": \"charlie@example.com\",\n" +
                "      \"phone\": \"123-456-7890\"\n" +
                "    }\n" +
                "  },\n" +
                "  \"tags\": [\"java\", \"json\", \"api\"]\n" +
                "}";
        JSONObject root = new JSONObject(complexJsonString);
        // 获取嵌套的 user 对象
        JSONObject userObject = root.getJSONObject("user");
        // 从 user 对象中获取 name
        String userName = userObject.getString("name");
        System.out.println("User Name: " + userName); // 输出: User Name: Charlie
        // 获取更深层的 contact 对象
        JSONObject contactObject = userObject.getJSONObject("contact");
        String userEmail = contactObject.getString("email");
        System.out.println("User Email: " + userEmail); // 输出: User Email: charlie@example.com
        // 获取数组
        // org.json.JSONArray 需要单独导入
        org.json.JSONArray tagsArray = root.getJSONArray("tags");
        System.out.println("Tags:");
        for (int i = 0; i < tagsArray.length(); i++) {
            System.out.println("- " + tagsArray.getString(i));
        }
    }
}

总结与最佳实践

核心要点：

1. org.json 库：轻量级，适合处理简单的 JSON 数据。
2. 手动解析是王道：对于生产环境代码，手动解析 JSONObject 来创建你的业务对象（POJO）是最可靠的方式。
3. 处理嵌套：使用 getJSONObject() 和 getJSONArray() 来逐层深入解析复杂的 JSON 结构。
4. 错误处理：在调用 getXXX() 方法时，如果键不存在或类型不匹配，会抛出 JSONException，最好使用 optXXX() 系列方法（如 optString(), optInt()）来避免异常，它们在键不存在时会返回默认值（如 null, 0）。

// optXXX() 的使用示例
String name = root.optString("name", "default_name"); // "name" 不存在，返回 "default_name"
int age = root.optInt("age"); // "age" 不存在，返回 0