核心思路

无论使用哪个库,核心思路都是：

1. 解析 JSON 字符串：将 JSON 字符串解析成一个内存中的 JSON 对象（JSONObject 或 JsonNode）。
2. 提取值：从这个 JSON 对象中，获取你想要的那个数组（Array）字段。
3. 转换为 Java 数组：将提取出的 JSON 数组转换成一个 Java 的 String[] 数组。

准备工作：添加 JSON 库依赖

如果你使用的是 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 提供的另一个非常流行的 JSON 库，使用简单。

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

org.json

这是一个轻量级的 JSON 库，API 简单直接。

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

示例 JSON

我们将使用以下 JSON 对象作为示例：

{
  "userId": "12345",
  "userName": "张三",
  "roles": ["admin", "editor", "user"],
  "permissions": ["read", "write"]
}

我们的目标是从这个 JSON 中提取 "roles" 字段，得到 ["admin", "editor", "user"] 这个字符串数组。

使用 Jackson (推荐)

Jackson 的核心类是 ObjectMapper，它非常强大。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
    public static void main(String[] args) {
        String jsonString = "{\n" +
                "  \"userId\": \"12345\",\n" +
                "  \"userName\": \"张三\",\n" +
                "  \"roles\": [\"admin\", \"editor\", \"user\"],\n" +
                "  \"permissions\": [\"read\", \"write\"]\n" +
                "}";
        // 1. 创建 ObjectMapper 实例
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 2. 将 JSON 字符串解析为 JsonNode 对象
            JsonNode rootNode = objectMapper.readTree(jsonString);
            // 3. 获取 "roles" 数组节点
            JsonNode rolesNode = rootNode.get("roles");
            // 4. 将 JsonNode 数组转换为 Java 字符串数组
            //    objectMapper.treeToValue() 可以直接将 JsonNode 转换为目标类型的 Java 对象
            String[] rolesArray = objectMapper.treeToValue(rolesNode, String[].class);
            // 打印结果
            System.out.println("使用 Jackson 转换结果:");
            for (String role : rolesArray) {
                System.out.println(role);
            }
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

输出:

使用 Jackson 转换结果:
admin
editor
user

使用 Google Gson

Gson 的核心类是 Gson，使用起来也很直观。

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
public class GsonExample {
    public static void main(String[] args) {
        String jsonString = "{\n" +
                "  \"userId\": \"12345\",\n" +
                "  \"userName\": \"张三\",\n" +
                "  \"roles\": [\"admin\", \"editor\", \"user\"],\n" +
                "  \"permissions\": [\"read\", \"write\"]\n" +
                "}";
        // 1. 创建 Gson 实例
        Gson gson = new Gson();
        // 2. 将 JSON 字符串解析为 JsonObject
        JsonObject jsonObject = JsonParser.parseString(jsonString).getAsJsonObject();
        // 3. 从 JsonObject 中获取 "roles" 数组
        JsonArray rolesJsonArray = jsonObject.getAsJsonArray("roles");
        // 4. 将 JsonArray 转换为 String[]
        String[] rolesArray = gson.fromJson(rolesJsonArray, String[].class);
        // 打印结果
        System.out.println("使用 Gson 转换结果:");
        for (String role : rolesArray) {
            System.out.println(role);
        }
    }
}

输出:

使用 Gson 转换结果:
admin
editor
user

使用 org.json

这个库的 API 比较传统，需要手动处理类型转换。

import org.json.JSONArray;
import org.json.JSONObject;
public class OrgJsonExample {
    public static void main(String[] args) {
        String jsonString = "{\n" +
                "  \"userId\": \"12345\",\n" +
                "  \"userName\": \"张三\",\n" +
                "  \"roles\": [\"admin\", \"editor\", \"user\"],\n" +
                "  \"permissions\": [\"read\", \"write\"]\n" +
                "}";
        // 1. 将 JSON 字符串解析为 JSONObject
        JSONObject jsonObject = new JSONObject(jsonString);
        // 2. 从 JSONObject 中获取 "roles" 数组
        JSONArray rolesJsonArray = jsonObject.getJSONArray("roles");
        // 3. 创建一个新的 String 数组
        String[] rolesArray = new String[rolesJsonArray.length()];
        // 4. 遍历 JSONArray，将每个元素赋值给 String 数组
        for (int i = 0; i < rolesJsonArray.length(); i++) {
            rolesArray[i] = rolesJsonArray.getString(i);
        }
        // 打印结果
        System.out.println("使用 org.json 转换结果:");
        for (String role : rolesArray) {
            System.out.println(role);
        }
    }
}

输出:

使用 org.json 转换结果:
admin
editor
user

总结与对比

对于大多数现代 Java 项目，特别是基于 Spring Boot 的项目，强烈推荐使用 Jackson，它不仅性能卓越，而且功能非常强大，是事实上的行业标准，如果你的项目已经有 Gson 依赖或者你更喜欢它的 API，Gson 也是一个非常好的选择。org.json 则更适合做一些简单的、一次性的 JSON 处理任务。