如何在 Java 中解析 JSON

org.json 库易于使用。

请记住（在强制转换或使用 getJSONObject 和 getJSONArray 等方法时）JSON 表示法

... ] 表示一个数组，因此库会将其解析为 JSONArray

{ ... } 表示一个对象，因此库会将其解析为 JSONObject

下面的示例代码：

import org.json.*;

String jsonString = ... ; //assign your JSON String here
JSONObject obj = new JSONObject(jsonString);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts"); // notice that `"posts": [...]`
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......
}

您可以从以下位置找到更多示例：Parse JSON in Java

可下载的 jar：http://mvnrepository.com/artifact/org.json/json

---

为了示例的目的，假设您有一个只有 name 的类 Person。

private class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

谷歌 GSON (Maven)

我个人最喜欢的对象是伟大的 JSON 序列化/反序列化。

Gson g = new Gson();

Person person = g.fromJson("{\"name\": \"John\"}", Person.class);
System.out.println(person.name); //John

System.out.println(g.toJson(person)); // {"name":"John"}

更新

如果您想获取单个属性，您也可以使用 Google 库轻松完成：

JsonObject jsonObject = new JsonParser().parse("{\"name\": \"John\"}").getAsJsonObject();

System.out.println(jsonObject.get("name").getAsString()); //John

组织.JSON (Maven)

如果您不需要对象反序列化而只是获取属性，则可以尝试 org.json （或查看上面的 GSON 示例！）

JSONObject obj = new JSONObject("{\"name\": \"John\"}");

System.out.println(obj.getString("name")); //John

杰克逊（马文）

ObjectMapper mapper = new ObjectMapper();
Person user = mapper.readValue("{\"name\": \"John\"}", Person.class);

System.out.println(user.name); //John

---

如果想从 JSON 创建 Java 对象，反之亦然，请使用 GSON 或 JACKSON 第三方 jar 等。 //从对象到 JSON Gson gson = new Gson(); gson.toJson(yourObject); // 从 JSON 到对象 yourObject o = gson.fromJson(JSONString,yourObject.class);但是，如果只想解析 JSON 字符串并获取一些值，（或从头开始创建 JSON 字符串以通过线路发送）只需使用包含 JsonReader、JsonArray、JsonObject 等的 JaveEE jar。您可能需要下载该实现像 javax.json 这样的规范。有了这两个罐子，我就可以解析 json 并使用这些值。这些 API 实际上遵循 XML 的 DOM/SAX 解析模型。响应响应 = request.get(); // REST 调用 JsonReader jsonReader = Json.createReader(new StringReader(response.readEntity(String.class))); JsonArray jsonArray = jsonReader.readArray(); ListIterator l = jsonArray.listIterator();而 ( l.hasNext() ) { JsonObject j = (JsonObject)l.next(); JsonObject ciAttr = j.getJsonObject("ciAttributes");

---

quick-json parser 非常简单、灵活、快速且可自定义。试试看

特征：

符合 JSON 规范 (RFC4627)

高性能 JSON 解析器

支持灵活/可配置的解析方法

任何 JSON 层次结构的键/值对的可配置验证

易于使用 # 占用空间非常小

提高对开发人员友好且易于跟踪的异常

可插入的自定义验证支持 - 可以通过在遇到时配置自定义验证器来验证键/值

验证和非验证解析器支持

支持两种类型的配置 (JSON/XML) 以使用快速 JSON 验证解析器

需要 JDK 1.5

不依赖外部库

通过对象序列化支持 JSON 生成

支持解析过程中的集合类型选择

它可以这样使用：

JsonParserFactory factory=JsonParserFactory.getInstance();
JSONParser parser=factory.newJsonParser();
Map jsonMap=parser.parseJson(jsonString);

---

您可以使用 Google Gson。

使用这个库，您只需要创建一个具有相同 JSON 结构的模型。然后模型会自动填充。您必须将变量称为 JSON 键，或者如果您想使用不同的名称，请使用 @SerializedName。

JSON

从你的例子：

{
    "pageInfo": {
        "pageName": "abc",
        "pagePic": "http://example.com/content.jpg"
    }
    "posts": [
        {
            "post_id": "123456789012_123456789012",
            "actor_id": "1234567890",
            "picOfPersonWhoPosted": "http://example.com/photo.jpg",
            "nameOfPersonWhoPosted": "Jane Doe",
            "message": "Sounds cool. Can't wait to see it!",
            "likesCount": "2",
            "comments": [],
            "timeOfPost": "1234567890"
        }
    ]
}

模型

class MyModel {

    private PageInfo pageInfo;
    private ArrayList<Post> posts = new ArrayList<>();
}

class PageInfo {

    private String pageName;
    private String pagePic;
}

class Post {

    private String post_id;

    @SerializedName("actor_id") // <- example SerializedName
    private String actorId;

    private String picOfPersonWhoPosted;
    private String nameOfPersonWhoPosted;
    private String message;
    private String likesCount;
    private ArrayList<String> comments;
    private String timeOfPost;
}

解析

现在您可以使用 Gson 库进行解析：

MyModel model = gson.fromJson(jsonString, MyModel.class);

Gradle 导入

记得在 app Gradle 文件中导入库

implementation 'com.google.code.gson:gson:2.8.6' // or earlier versions

自动模型生成

您可以使用 this 等在线工具自动从 JSON 生成模型。

---

A - 解释

您可以使用 Jackson 库将 JSON 字符串绑定到 POJO（普通旧 Java 对象）实例。 POJO 只是一个只有私有字段和公共 getter/setter 方法的类。 Jackson 将遍历方法（使用反射），并将 JSON 对象映射到 POJO 实例，因为类的字段名称适合 JSON 对象的字段名称。

在您的 JSON 对象（实际上是一个复合对象）中，主对象由两个子对象组成。因此，我们的 POJO 类应该具有相同的层次结构。我将把整个 JSON 对象称为 Page 对象。 Page 对象由一个 PageInfo 对象和一个 Post 对象数组组成。

所以我们必须创建三个不同的 POJO 类；

Page 类，PageInfo 类和 Post 实例数组的组合

页面信息类

帖子类

我用过的唯一包是Jackson ObjectMapper，我们做的是绑定数据；

com.fasterxml.jackson.databind.ObjectMapper

需要的依赖，jar文件在下面列出；

杰克逊核心-2.5.1.jar

jackson-databind-2.5.1.jar

杰克逊注释-2.5.0.jar

这是所需的代码；

B - 主 POJO 类：页面

package com.levo.jsonex.model;

public class Page {
    
    private PageInfo pageInfo;
    private Post[] posts;

    public PageInfo getPageInfo() {
        return pageInfo;
    }

    public void setPageInfo(PageInfo pageInfo) {
        this.pageInfo = pageInfo;
    }

    public Post[] getPosts() {
        return posts;
    }

    public void setPosts(Post[] posts) {
        this.posts = posts;
    }
    
}

C - 子 POJO 类：PageInfo

package com.levo.jsonex.model;

public class PageInfo {
    
    private String pageName;
    private String pagePic;
    
    public String getPageName() {
        return pageName;
    }
    
    public void setPageName(String pageName) {
        this.pageName = pageName;
    }
    
    public String getPagePic() {
        return pagePic;
    }
    
    public void setPagePic(String pagePic) {
        this.pagePic = pagePic;
    }
    
}

D - 子 POJO 类：发布

package com.levo.jsonex.model;

public class Post {
    
    private String post_id;
    private String actor_id;
    private String picOfPersonWhoPosted;
    private String nameOfPersonWhoPosted;
    private String message;
    private int likesCount;
    private String[] comments;
    private int timeOfPost;

    public String getPost_id() {
        return post_id;
    }

    public void setPost_id(String post_id) {
        this.post_id = post_id;
    }

    public String getActor_id() {
        return actor_id;
    }

    public void setActor_id(String actor_id) {
        this.actor_id = actor_id;
    }

    public String getPicOfPersonWhoPosted() {
        return picOfPersonWhoPosted;
    }
    
    public void setPicOfPersonWhoPosted(String picOfPersonWhoPosted) {
        this.picOfPersonWhoPosted = picOfPersonWhoPosted;
    }

    public String getNameOfPersonWhoPosted() {
        return nameOfPersonWhoPosted;
    }

    public void setNameOfPersonWhoPosted(String nameOfPersonWhoPosted) {
        this.nameOfPersonWhoPosted = nameOfPersonWhoPosted;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public int getLikesCount() {
        return likesCount;
    }

    public void setLikesCount(int likesCount) {
        this.likesCount = likesCount;
    }

    public String[] getComments() {
        return comments;
    }

    public void setComments(String[] comments) {
        this.comments = comments;
    }

    public int getTimeOfPost() {
        return timeOfPost;
    }

    public void setTimeOfPost(int timeOfPost) {
        this.timeOfPost = timeOfPost;
    }
    
}

- 示例 JSON 文件：sampleJSONFile.json

我刚刚将您的 JSON 示例复制到此文件中，并将其放在项目文件夹下。

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    },
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
         }
    ]
}

F - 演示代码

package com.levo.jsonex;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.levo.jsonex.model.Page;
import com.levo.jsonex.model.PageInfo;
import com.levo.jsonex.model.Post;

public class JSONDemo {
    
    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();
        
        try {
            Page page = objectMapper.readValue(new File("sampleJSONFile.json"), Page.class);
            
            printParsedObject(page);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
    
    private static void printParsedObject(Page page) {
        printPageInfo(page.getPageInfo());
        System.out.println();
        printPosts(page.getPosts());
    }

    private static void printPageInfo(PageInfo pageInfo) {
        System.out.println("Page Info;");
        System.out.println("**********");
        System.out.println("\tPage Name : " + pageInfo.getPageName());
        System.out.println("\tPage Pic  : " + pageInfo.getPagePic());
    }
    
    private static void printPosts(Post[] posts) {
        System.out.println("Page Posts;");
        System.out.println("**********");
        for(Post post : posts) {
            printPost(post);
        }
    }
    
    private static void printPost(Post post) {
        System.out.println("\tPost Id                   : " + post.getPost_id());
        System.out.println("\tActor Id                  : " + post.getActor_id());
        System.out.println("\tPic Of Person Who Posted  : " + post.getPicOfPersonWhoPosted());
        System.out.println("\tName Of Person Who Posted : " + post.getNameOfPersonWhoPosted());
        System.out.println("\tMessage                   : " + post.getMessage());
        System.out.println("\tLikes Count               : " + post.getLikesCount());
        System.out.println("\tComments                  : " + Arrays.toString(post.getComments()));
        System.out.println("\tTime Of Post              : " + post.getTimeOfPost());
    }
    
}

- 演示输出

Page Info;
****(*****
    Page Name : abc
    Page Pic  : http://example.com/content.jpg
Page Posts;
**********
    Post Id                   : 123456789012_123456789012
    Actor Id                  : 1234567890
    Pic Of Person Who Posted  : http://example.com/photo.jpg
    Name Of Person Who Posted : Jane Doe
    Message                   : Sounds cool. Can't wait to see it!
    Likes Count               : 2
    Comments                  : []
    Time Of Post              : 1234567890

---

几乎所有给出的答案都需要在访问感兴趣的属性中的值之前将 JSON 完全反序列化为 Java 对象。另一种不走这条路线的替代方法是使用 JsonPATH，它类似于 JSON 的 XPath，并允许遍历 JSON 对象。

这是一个规范，JayWay 的优秀人员已经为该规范创建了一个 Java 实现，您可以在此处找到：https://github.com/jayway/JsonPath

所以基本上要使用它，将它添加到您的项目中，例如：

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>${version}</version>
</dependency>

并使用：

String pageName = JsonPath.read(yourJsonString, "$.pageInfo.pageName");
String pagePic = JsonPath.read(yourJsonString, "$.pageInfo.pagePic");
String post_id = JsonPath.read(yourJsonString, "$.pagePosts[0].post_id");

ETC...

查看 JsonPath 规范页面以获取有关横向 JSON 的其他方式的更多信息。

---

使用非常快速且易于使用的 minimal-json。您可以从 String obj 和 Stream 解析。

样本数据：

{
  "order": 4711,
  "items": [
    {
      "name": "NE555 Timer IC",
      "cat-id": "645723",
      "quantity": 10,
    },
    {
      "name": "LM358N OpAmp IC",
      "cat-id": "764525",
      "quantity": 2
    }
  ]
}

解析：

JsonObject object = Json.parse(input).asObject();
int orders = object.get("order").asInt();
JsonArray items = object.get("items").asArray();

创建 JSON：

JsonObject user = Json.object().add("name", "Sakib").add("age", 23);

马文：

<dependency>
  <groupId>com.eclipsesource.minimal-json</groupId>
  <artifactId>minimal-json</artifactId>
  <version>0.9.4</version>
</dependency>

---

下面的示例显示了如何阅读问题中的文本，表示为“jsonText”变量。此解决方案使用 Java EE7 javax.json API（在其他一些答案中提到）。我将其添加为单独答案的原因是以下代码显示了如何实际上访问问题中显示的一些值。需要 implementation of the javax.json API 才能运行此代码。因为我不想声明“import”语句，所以包含了每个所需类的完整包。

javax.json.JsonReader jr = 
    javax.json.Json.createReader(new StringReader(jsonText));
javax.json.JsonObject jo = jr.readObject();

//Read the page info.
javax.json.JsonObject pageInfo = jo.getJsonObject("pageInfo");
System.out.println(pageInfo.getString("pageName"));

//Read the posts.
javax.json.JsonArray posts = jo.getJsonArray("posts");
//Read the first post.
javax.json.JsonObject post = posts.getJsonObject(0);
//Read the post_id field.
String postId = post.getString("post_id");

现在，在任何人因为它不使用 GSON、org.json、Jackson 或任何其他可用的第 3 方框架而对这个答案投反对票之前，它是解析所提供文本的每个问题的“必需代码”示例。我很清楚 adherence to the current standard JSR 353 was not being considered for JDK 9 以及 JSR 353 spec 应该与任何其他第 3 方 JSON 处理实现一样对待。

---

由于尚未有人提及它，因此这里是使用 Nashorn（Java 8 的 JavaScript 运行时部分，但在 Java 11 中已弃用）的解决方案的开始。

解决方案

private static final String EXTRACTOR_SCRIPT =
    "var fun = function(raw) { " +
    "var json = JSON.parse(raw); " +
    "return [json.pageInfo.pageName, json.pageInfo.pagePic, json.posts[0].post_id];};";

public void run() throws ScriptException, NoSuchMethodException {
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    engine.eval(EXTRACTOR_SCRIPT);
    Invocable invocable = (Invocable) engine;
    JSObject result = (JSObject) invocable.invokeFunction("fun", JSON);
    result.values().forEach(e -> System.out.println(e));
}

性能比较

我编写的 JSON 内容包含三个数组，分别为 20、20 和 100 个元素。我只想从第三个数组中获取 100 个元素。我使用以下 JavaScript 函数来解析和获取我的条目。

var fun = function(raw) {JSON.parse(raw).entries};

使用 Nashorn 运行一百万次调用需要 7.5~7.8 秒

(JSObject) invocable.invokeFunction("fun", json);

org.json 需要 20~21 秒

new JSONObject(JSON).getJSONArray("entries");

杰克逊需要 6.5~7 秒

mapper.readValue(JSON, Entries.class).getEntries();

在这种情况下，Jackson 的性能优于 Nashorn，后者的性能比 org.json 好得多。 Nashorn API 比 org.json 或 Jackson 更难使用。根据您的要求，Jackson 和 Nashorn 都是可行的解决方案。

---

我认为最佳做法应该是通过仍在进行中的官方Java JSON API。

---

这让我大吃一惊，因为它是多么容易。您可以将保存 JSON 的 String 传递给默认 org.json 包中 JSONObject 的构造函数。

JSONArray rootOfPage =  new JSONArray(JSONString);

完毕。 麦克风掉落。这也适用于 JSONObjects。之后，您可以使用对象上的 get() 方法查看 Objects 的层次结构。

---

Java 中有许多可用的 JSON 库。

最臭名昭著的是：Jackson、GSON、Genson、FastJson 和 org.json。

在选择任何库时，通常应该考虑三件事：

性能 易于使用（代码易于编写且清晰易读） - 与功能相得益彰。对于移动应用程序：依赖项/jar 大小

特别是对于 JSON 库（以及任何序列化/反序列化库），数据绑定通常也很有趣，因为它无需编写样板代码来打包/解包数据。

对于 1，请参阅此基准：https://github.com/fabienrenaud/java-json-benchmark 我使用 JMH 比较了使用流和数据绑定 API 的序列化器和反序列化器的（jackson、gson、genson、fastjson、org.json、jsonp）性能。对于 2，您可以在 Internet 上找到大量示例。上面的基准也可以用作示例的来源......

快速了解基准：Jackson 的性能比 org.json 好 5 到 6 倍，比 GSON 好两倍多。

对于您的特定示例，以下代码使用杰克逊解码您的 json：

public class MyObj {

    private PageInfo pageInfo;
    private List<Post> posts;

    static final class PageInfo {
        private String pageName;
        private String pagePic;
    }

    static final class Post {
        private String post_id;
        @JsonProperty("actor_id");
        private String actorId;
        @JsonProperty("picOfPersonWhoPosted")
        private String pictureOfPoster;
        @JsonProperty("nameOfPersonWhoPosted")
        private String nameOfPoster;
        private String likesCount;
        private List<String> comments;
        private String timeOfPost;
    }

    private static final ObjectMapper JACKSON = new ObjectMapper();
    public static void main(String[] args) throws IOException {
        MyObj o = JACKSON.readValue(args[0], MyObj.class); // assumes args[0] contains your json payload provided in your question.
    }
}

如果您有任何问题，请告诉我。

---

除了其他答案，我推荐这个在线开源服务 jsonschema2pojo.org，以便从 GSON、Jackson 1.x 或 Jackson 2.x 的 json 或 json 模式快速生成 Java 类。例如，如果您有：

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    }
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": 1234567890,
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": 2,
              "comments": [],
              "timeOfPost": 1234567890
         }
    ]
}

GSON 的 jsonschema2pojo.org 生成：

@Generated("org.jsonschema2pojo")
public class Container {
    @SerializedName("pageInfo")
    @Expose
    public PageInfo pageInfo;
    @SerializedName("posts")
    @Expose
    public List<Post> posts = new ArrayList<Post>();
}

@Generated("org.jsonschema2pojo")
public class PageInfo {
    @SerializedName("pageName")
    @Expose
    public String pageName;
    @SerializedName("pagePic")
    @Expose
    public String pagePic;
}

@Generated("org.jsonschema2pojo")
public class Post {
    @SerializedName("post_id")
    @Expose
    public String postId;
    @SerializedName("actor_id")
    @Expose
    public long actorId;
    @SerializedName("picOfPersonWhoPosted")
    @Expose
    public String picOfPersonWhoPosted;
    @SerializedName("nameOfPersonWhoPosted")
    @Expose
    public String nameOfPersonWhoPosted;
    @SerializedName("message")
    @Expose
    public String message;
    @SerializedName("likesCount")
    @Expose
    public long likesCount;
    @SerializedName("comments")
    @Expose
    public List<Object> comments = new ArrayList<Object>();
    @SerializedName("timeOfPost")
    @Expose
    public long timeOfPost;
}

---

如果您有一些表示 JSON 字符串 (jsonString) 的 Java 类（例如 Message），您可以使用 Jackson JSON 库：

Message message= new ObjectMapper().readValue(jsonString, Message.class);

并且从消息对象中，您可以获取其任何属性。

---

Gson易于学习和实现，我们需要了解以下两种方法

toJson() – 将 Java 对象转换为 JSON 格式

fromJson() – 将 JSON 转换为 Java 对象

`

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import com.google.gson.Gson;

public class GsonExample {
    public static void main(String[] args) {

    Gson gson = new Gson();

    try {

        BufferedReader br = new BufferedReader(
            new FileReader("c:\\file.json"));

        //convert the json string back to object
        DataObject obj = gson.fromJson(br, DataObject.class);

        System.out.println(obj);

    } catch (IOException e) {
        e.printStackTrace();
    }

    }
}

`

---

有许多开源库可用于将 JSON 内容解析为对象或仅用于读取 JSON 值。您的要求只是读取值并将其解析为自定义对象。所以 org.json 库在你的情况下就足够了。

使用 org.json 库对其进行解析并创建 JsonObject：

JSONObject jsonObj = new JSONObject(<jsonStr>);

现在，使用此对象获取您的值：

String id = jsonObj.getString("pageInfo");

你可以在这里看到一个完整的例子：

How to parse JSON in Java

---

阅读以下博文，JSON in Java。

这篇文章有点老了，但我仍然想回答你的问题。

第 1 步：创建数据的 POJO 类。

第 2 步：现在使用 JSON 创建一个对象。

Employee employee = null;
ObjectMapper mapper = new ObjectMapper();
try {
    employee =  mapper.readValue(newFile("/home/sumit/employee.json"), Employee.class);
} 
catch(JsonGenerationException e) {
    e.printStackTrace();
}

如需进一步参考，您可以参考以下link。

---

您可以使用 Gson 库来解析 JSON 字符串。

Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(jsonAsString, JsonObject.class);

String pageName = jsonObject.getAsJsonObject("pageInfo").get("pageName").getAsString();
String pagePic = jsonObject.getAsJsonObject("pageInfo").get("pagePic").getAsString();
String postId = jsonObject.getAsJsonArray("posts").get(0).getAsJsonObject().get("post_id").getAsString();

您还可以像这样循环遍历“posts”数组：

JsonArray posts = jsonObject.getAsJsonArray("posts");
for (JsonElement post : posts) {
  String postId = post.getAsJsonObject().get("post_id").getAsString();
  //do something
}

---

我有这样的 JSON：

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    }
}

Java 类

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

将此 JSON 转换为 Java 类的代码。

    PageInfo pageInfo = JsonPath.parse(jsonString).read("$.pageInfo", PageInfo.class);

马文

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>2.2.0</version>
</dependency>

---

请做这样的事情：

JSONParser jsonParser = new JSONParser();
JSONObject obj = (JSONObject) jsonParser.parse(contentString);
String product = (String) jsonObject.get("productId");

---

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    },
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
         }
    ]
}

Java code :

JSONObject obj = new JSONObject(responsejsonobj);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......etc
}

---

首先，您需要选择一个实现库来执行此操作。

用于 JSON 处理的 Java API (JSR 353) 提供可移植的 API 以使用对象模型和流 API 解析、生成、转换和查询 JSON。

参考实现在这里：https://jsonp.java.net/

在这里您可以找到 JSR 353 的实现列表：

What are the API that does implement JSR-353 (JSON)

为了帮助您做出决定……我也找到了这篇文章：

http://blog.takipi.com/the-ultimate-json-library-json-simple-vs-gson-vs-jackson-vs-json/

如果您选择 Jackson，这里有一篇关于使用 Jackson 在 JSON 与 Java 之间进行转换的好文章：https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

希望能帮助到你！

---

此页面上的热门答案使用了过于简单的示例，例如具有一个属性的对象（例如 {name: value}）。我认为这个仍然简单但真实的例子可以帮助某人。

这是谷歌翻译 API 返回的 JSON：

{
  "data": 
     {
        "translations": 
          [
            {
              "translatedText": "Arbeit"
             }
          ]
     }
}

我想使用 Google 的 Gson 检索“translatedText”属性的值，例如“Arbeit”。

两种可能的方法：

只检索一个需要的属性 String json = callToTranslateApi("work", "de"); JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject(); return jsonObject.get("data").getAsJsonObject() .get("translations").getAsJsonArray() .get(0).getAsJsonObject() .get("translatedText").getAsString();从 JSON 类 ApiResponse { Data data; 创建 Java 对象类数据{翻译[]翻译；类翻译 { 字符串翻译文本； } } } ... Gson g = new Gson(); String json =callToTranslateApi("work", "de"); ApiResponse 响应 = g.fromJson(json, ApiResponse.class);返回 response.data.translations[0].translatedText；

---

您可以使用 Jayway JsonPath。下面是一个包含源代码、pom 详细信息和良好文档的 GitHub 链接。

https://github.com/jayway/JsonPath

请按照以下步骤操作。

第 1 步：使用 Maven 在类路径中添加 jayway JSON 路径依赖项，或下载 JAR 文件并手动添加。

<dependency>
            <groupId>com.jayway.jsonpath</groupId>
            <artifactId>json-path</artifactId>
            <version>2.2.0</version>
</dependency>

第 2 步：请将您的输入 JSON 保存为此示例的文件。就我而言，我将您的 JSON 保存为 sampleJson.txt。请注意，您错过了 pageInfo 和帖子之间的逗号。

第 3 步：使用 bufferedReader 从上述文件中读取 JSON 内容并将其保存为 String。

BufferedReader br = new BufferedReader(new FileReader("D:\\sampleJson.txt"));

StringBuilder sb = new StringBuilder();
String line = br.readLine();

while (line != null) {
    sb.append(line);
    sb.append(System.lineSeparator());
    line = br.readLine();
}
br.close();
String jsonInput = sb.toString();

第 4 步：使用 jayway JSON 解析器解析您的 JSON 字符串。

Object document = Configuration.defaultConfiguration().jsonProvider().parse(jsonInput);

第 5 步：阅读以下详细信息。

String pageName = JsonPath.read(document, "$.pageInfo.pageName");
String pagePic = JsonPath.read(document, "$.pageInfo.pagePic");
String post_id = JsonPath.read(document, "$.posts[0].post_id");

System.out.println("$.pageInfo.pageName " + pageName);
System.out.println("$.pageInfo.pagePic " + pagePic);
System.out.println("$.posts[0].post_id " + post_id);

输出将是：

$.pageInfo.pageName = abc
$.pageInfo.pagePic = http://example.com/content.jpg
$.posts[0].post_id  = 123456789012_123456789012

---

如果您有 maven 项目，则添加以下依赖项或普通项目添加 json-simple jar。

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

在下面编写将 JSON 字符串转换为 JSON 数组的 java 代码。

JSONArray ja = new JSONArray(String jsonString);

---

可以使用 Apache @Model annotation 创建表示 JSON 文件结构的 Java 模型类，并使用它们访问 JSON 树中的各种元素。与其他解决方案不同，它完全无需反射，因此适用于无法进行反射或需要大量开销的环境。

有一个 sample Maven project 显示用法。首先它定义了结构：

@Model(className="RepositoryInfo", properties = {
    @Property(name = "id", type = int.class),
    @Property(name = "name", type = String.class),
    @Property(name = "owner", type = Owner.class),
    @Property(name = "private", type = boolean.class),
})
final class RepositoryCntrl {
    @Model(className = "Owner", properties = {
        @Property(name = "login", type = String.class)
    })
    static final class OwnerCntrl {
    }
}

然后它使用生成的 RepositoryInfo 和 Owner 类来解析提供的输入流并在执行此操作时选择某些信息：

List<RepositoryInfo> repositories = new ArrayList<>();
try (InputStream is = initializeStream(args)) {
    Models.parse(CONTEXT, RepositoryInfo.class, is, repositories);
}

System.err.println("there is " + repositories.size() + " repositories");
repositories.stream().filter((repo) -> repo != null).forEach((repo) -> {
    System.err.println("repository " + repo.getName() + 
        " is owned by " + repo.getOwner().getLogin()
    );
})

这就对了！除此之外，这里还有一个 live gist 显示了类似的示例以及异步网络通信。

---

jsoniter (jsoniterator) 是一个相对较新且简单的 json 库，旨在简单快速。反序列化 json 数据所需要做的就是

JsonIterator.deserialize(jsonData, int[].class);

其中 jsonData 是一串 json 数据。

查看 official website 了解更多信息。

---

解决问题的任何类型的 json 数组步骤。

将您的 JSON 对象转换为 java 对象。您可以使用此链接或任何在线工具。保存为像 Myclass.java 这样的 java 类。 Myclass obj = new Gson().fromJson(JsonStr, Myclass.class);使用 obj，您可以获得您的值。

---

您可以将 JsonNode 用于 JSON 字符串的结构化树表示。它是无所不在的坚如磐石的jackson library的一部分。

ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");

---