java怎么将json取出来

Java中如何高效提取JSON数据：从基础到实战

在Java开发中,JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，广泛应用于前后端数据交互、配置文件存储、API接口响应等场景，如何从JSON数据中提取所需信息，是每一位Java开发者的必备技能，本文将系统介绍Java中提取JSON数据的多种方法，从原生操作到第三方库实战，帮助不同需求的开发者选择合适的解决方案。

JSON数据基础：认识“键值对”结构

在开始提取数据前,先简单回顾JSON的核心结构，JSON数据主要由两种形式组成：

• 对象（Object）：用 表示，无序的键值对集合，键是字符串，值可以是字符串、数字、布尔值、数组、对象或null，

  {"name": "张三", "age": 25, "isStudent": false, "courses": ["数学", "英语"]}

• 数组（Array）：用 [] 表示，有序的值集合，值可以是任意JSON类型，

  [{"name": "李四", "age": 22}, {"name": "王五", "age": 23}]

提取JSON数据,本质上就是根据键（对象）或索引（数组）获取对应的值，并处理嵌套的复杂结构。

原生方式：使用org.json库（JDK内置无需额外依赖）

Java标准库中并未直接提供JSON处理工具,但org.json是一个轻量级、无需额外依赖的第三方库（可通过JDK的javax.json实现，或直接使用org.json包），这里以org.json为例，介绍原生操作方式。

添加依赖（若使用Maven）

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20231013</version>
</dependency>

提取JSON对象数据

假设我们有以下JSON字符串（对象类型）：

{"name": "张三", "age": 25, "isStudent": false, "address": {"city": "北京", "district": "朝阳区"}}

提取步骤如下：

（1）创建JSONObject对象

import org.json.JSONObject;
String jsonStr = "{\"name\": \"张三\", \"age\": 25, \"isStudent\": false, \"address\": {\"city\": \"北京\", \"district\": \"朝阳区\"}}";
JSONObject jsonObject = new JSONObject(jsonStr);

（2）获取简单类型值

使用getString()、getInt()、getBoolean()等方法直接获取：

String name = jsonObject.getString("name"); // "张三"
int age = jsonObject.getInt("age");       // 25
boolean isStudent = jsonObject.getBoolean("isStudent"); // false

（3）获取嵌套对象

若键对应的值是对象,需先转换为JSONObject，再提取其属性：

JSONObject addressObj = jsonObject.getJSONObject("address");
String city = addressObj.getString("city");     // "北京"
String district = addressObj.getString("district"); // "朝阳区"

（4）处理缺失键（避免异常）

使用optXXX()方法，若键不存在则返回默认值（而非抛出异常）：

String gender = jsonObject.optString("gender", "未知"); // 键不存在，返回"未知"

提取JSON数组数据

假设有以下JSON字符串（数组类型）：

[{"name": "李四", "age": 22}, {"name": "王五", "age": 23}]

提取步骤如下：

（1）创建JSONArray对象

import org.json.JSONArray;
String jsonArrayStr = "[{\"name\": \"李四\", \"age\": 22}, {\"name\": \"王五\", \"age\": 23}]";
JSONArray jsonArray = new JSONArray(jsonArrayStr);

（2）遍历数组并提取元素

通过length()获取数组长度，用getJSONObject(index)获取每个元素：

for (int i = 0; i < jsonArray.length(); i++) {
    JSONObject personObj = jsonArray.getJSONObject(i);
    String name = personObj.getString("name");
    int age = personObj.getInt("age");
    System.out.println("姓名: " + name + ", 年龄: " + age);
}
// 输出：
// 姓名: 李四, 年龄: 22
// 姓名: 王五, 年龄: 23

原生方式的优缺点

• 优点：无需额外依赖（若org.json已包含在JDK中），适合简单JSON处理。
• 缺点：代码冗长，嵌套结构处理复杂，缺乏类型安全（需手动转换类型）。

第三方库：Jackson与Gson（业界主流实践）

实际开发中,原生方式效率较低，更多使用成熟的第三方库（如Jackson、Gson、Fastjson），它们提供更简洁的API、更强的类型支持和灵活的配置。

（一）Jackson：高性能JSON处理器

Jackson是Java生态中最流行的JSON库之一,广泛用于Spring框架等主流项目，具有高性能、低内存占用的特点。

添加依赖（Maven）

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

将JSON字符串转换为Java对象（反序列化）

Jackson的核心优势是通过绑定POJO（普通Java对象）实现自动映射，避免手动提取键值对。

步骤1：定义与JSON结构对应的POJO

// 简单对象
public class Person {
    private String name;
    private int age;
    private boolean isStudent;
    // 必须提供无参构造方法（Jackson反射需要）
    public Person() {}
    // getter/setter
    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 isStudent() { return isStudent; }
    public void setStudent(boolean student) { isStudent = student; }
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", isStudent=" + isStudent + "}";
    }
}
// 嵌套对象（Address）
public class Address {
    private String city;
    private String district;
    // 无参构造方法 + getter/setter
    public Address() {}
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
    public String getDistrict() { return district; }
    public void setDistrict(String district) { this.district = district; }
    @Override
    public String toString() {
        return "Address{city='" + city + "', district='" + district + "'}";
    }
}
// 包含嵌套对象的Person
public class PersonWithAddress {
    private String name;
    private Address address;
    // 无参构造方法 + getter/setter
    public PersonWithAddress() {}
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }
    @Override
    public String toString() {
        return "PersonWithAddress{name='" + name + "', address=" + address + "}";
    }
}

步骤2：使用ObjectMapper解析JSON

import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonDemo {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        // 1. 解析简单JSON对象
        String simpleJson = "{\"name\": \"张三\", \"age\": 25, \"isStudent\": false}";
        Person person = objectMapper.readValue(simpleJson, Person.class);
        System.out.println("简单对象: " + person); // 输出: Person{name='张三', age=25, isStudent=false}
        // 2. 解析嵌套JSON对象
        String nestedJson = "{\"name\": \"李四\", \"address\": {\"city\": \"北京\", \"district\": \"朝阳区\"}}";
        PersonWithAddress personWithAddress = objectMapper.readValue(nestedJson, PersonWithAddress.class);
        System.out.println("嵌套对象: " + personWithAddress); 
        // 输出: PersonWithAddress{name='李四', address=Address{city='北京', district='朝阳区'}}
        // 3. 解析JSON数组
        String jsonArrayStr = "[{\"name\": \"王五\", \"age\": 22}, {\"name\": \"赵六\", \"age\": 23}]";
        Person[] personArray = objectMapper.readValue(jsonArrayStr, Person