如何在java中从JSONObject获取所有键/子键？

这是我的JSONObject：

{
    "per_page": 3,
    "total": 12,
    "data": [{
            "color": "#98B2D1",
            "year": 2000,
            "name": "cerulean",
            "id": 1,
            "pantone_value": "15-4020"
        }, {
            "color": "#C74375",
            "year": 2001,
            "name": "fuchsia rose",
            "id": 2,
            "pantone_value": "17-2031"
        }
    ],
    "page": 1,
    "total_pages": 4
}

从这里我可以得到所有的钥匙，包括

每页

，

总计

，

数据

，

颜色

，

年份

，

潘通价值

，

名称

，

页面

和

总计

如果我使用JSONObject.names（）或JSONObject.keySet（）。我只得到最外面的钥匙

package com.samples；
package com.samples;

import java.util.Iterator;

import gvjava.org.json.JSONArray;
import gvjava.org.json.JSONException;
import gvjava.org.json.JSONObject;

public class JSONObjectSample {

    public static void main (String [] args) {
        String jsonString = new String("{\"per_page\": 3,\"total\": 12,\"data\": [{\"color\": \"#98B2D1\",\"year\": 2000,\"name\": \"cerulean\",\"id\": 1,\"pantone_value\": \"15-4020\" }, {\"color\": \"#C74375\",\"year\": 2001,\"name\": \"fuchsia rose\",\"id\": 2,\"pantone_value\": \"17-2031\" }], \"page\": 1,\"total_pages\": 4 }\r\n");
        try {
            JSONObject jsonObject = new JSONObject(jsonString);
            Iterator<String> keys = jsonObject.keys();
            while(keys.hasNext()) {
                String key = keys.next();
                System.out.println(key);
                if(jsonObject.get(key) instanceof JSONArray) {
                    JSONArray array = (JSONArray) jsonObject.get(key);
                    JSONObject object = (JSONObject) array.get(0);
                    Iterator<String> innerKeys = object.keys();
                    while(innerKeys.hasNext()) {
                        String innerKey = innerKeys.next();
                        System.out.println(innerKey);
                    }
                }
            }

        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

导入java.util.Iterator；
导入gvjava.org.json.JSONArray；
导入gvjava.org.json.JSONException；
导入gvjava.org.json.JSONObject；
公共类JSONObject示例{
公共静态void main（字符串[]args）{
3、“总人数”12，，“数据”收集：：，，“数据”收集：：，，，，，“颜色”颜色：：：，，，今年：1年：2000年，年：2000年，年：2000年，年，年：2000年，年，年：2000年，“名称”名称：2000年，年：2000年，年：2000年，“名称”名称：2000年：2000年，名称：2000年，“名称”姓名：，，，“名称”名称：，，，，，，，，，，，，，，，“名称：，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，U页\“：4}\r\n”）；
试一试{
JSONObject JSONObject=新的JSONObject（jsonString）；
迭代器keys=jsonObject.keys（）；
while（keys.hasNext（））{
String key=keys.next（）；
系统输出打印项次（键）；
if（jsonObject.get（key）instanceof JSONArray）{
JSONArray数组=（JSONArray）jsonObject.get（key）；
JSONObject对象=（JSONObject）数组.get（0）；
迭代器innerKeys=object.keys（）；
while（innerKeys.hasNext（））{
字符串innerKey=innerKeys.next（）；
System.out.println（内键）；
}
}
}
}捕获（JSONException e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}

包装com.samples；
导入java.util.Iterator；
导入gvjava.org.json.JSONArray；
导入gvjava.org.json.JSONException；
导入gvjava.org.json.JSONObject；
公共类JSONObject示例{
公共静态void main（字符串[]args）{
3、“总人数”12，，“数据”收集：：，，“数据”收集：：，，，，，“颜色”颜色：：：，，，今年：1年：2000年，年：2000年，年：2000年，年，年：2000年，年，年：2000年，“名称”名称：2000年，年：2000年，年：2000年，“名称”名称：2000年：2000年，名称：2000年，“名称”姓名：，，，“名称”名称：，，，，，，，，，，，，，，，“名称：，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，U页\“：4}\r\n”）；
试一试{
JSONObject JSONObject=新的JSONObject（jsonString）；
迭代器keys=jsonObject.keys（）；
while（keys.hasNext（））{
String key=keys.next（）；
系统输出打印项次（键）；
if（jsonObject.get（key）instanceof JSONArray）{
JSONArray数组=（JSONArray）jsonObject.get（key）；
JSONObject对象=（JSONObject）数组.get（0）；
迭代器innerKeys=object.keys（）；
while（innerKeys.hasNext（））{
字符串innerKey=innerKeys.next（）；
System.out.println（内键）；
}
}
}
}捕获（JSONException e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}

您可以使用google gson对象解析器。（这不是很漂亮的代码，但它完成了任务）

import com.google.gson.JsonObject；
导入com.google.gson.JsonParser；
导入java.util.HashSet；
导入java.util.Set；
公共类获取密钥{
公共静态void main（字符串[]args）{
3、“总人数”12，“数据”数据：：“{”颜色：：“颜色：”：，，“98B2B2D1\”，“年”年：2000年，“年”年：2000年，“名称”名称：2000年，“名称”名称：2000年，“名称”名称：2000年：2000年，“名称”名称：2000年：2000年，“名称”名称：2000年，“名称”名称：“：\“蓝蓝蓝蓝蓝一”一页”，以及，“身份证”身份证：1，“id”身份证：1，身份证：1，“潘通通通的价值价值”价值价值价值”价值：1，“潘通通的价值”价值价值”价值：1，“15-40220-40220-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-“：4}\r\n”；
JsonParser=新的JsonParser（）；
JsonObject object=（JsonObject）parser.parse（jsonString）；
Set keys=new HashSet（）；
解析所有键（键、对象）；
keys.forEach（System.out:：println）；
}
私有静态void parseAllKeys（设置键、JsonObject对象）{
addAll（object.keySet（））；
object.entrySet（）.stream（）.filter（entry->entry.getValue（）.isJsonObject（））.forEach（entry->parseAllKeys（key，（JsonObject）entry.getValue（））；
object.entrySet（）.stream（）.filter（entry->entry.getValue（）.isJsonArray（））.forEach（entry->entry.getValue（）.getAsJsonArray（）.forEach（subEntry->parseallkey（key，（JsonObject）subEntry））；
}
}

您可以使用google gson对象解析器。（这不是很漂亮的代码，但它完成了任务）

import com.google.gson.JsonObject；
导入com.google.gson.JsonParser；
导入java.util.HashSet；
导入java.util.Set；
公共类获取密钥{
公共静态void main（字符串[]args）{
3、“总人数”12，“数据”数据：：“{”颜色：：“颜色：”：，，“98B2B2D1\”，“年”年：2000年，“年”年：2000年，“名称”名称：2000年，“名称”名称：2000年，“名称”名称：2000年：2000年，“名称”名称：2000年：2000年，“名称”名称：2000年，“名称”名称：“：\“蓝蓝蓝蓝蓝一”一页”，以及，“身份证”身份证：1，“id”身份证：1，身份证：1，“潘通通通的价值价值”价值价值价值”价值：1，“潘通通的价值”价值价值”价值：1，“15-40220-40220-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-“：4}\r\n”；
JsonParser=新的JsonParser（）；
JsonObject object=（JsonObject）parser.parse（jsonString）；
Set keys=new HashSet（）；
解析所有键（键、对象）；
keys.forEach（System.out:：println）；
}
私有静态void parseAllKeys（设置键、JsonObject对象）{
addAll（object.keySet（））；
object.entrySet（）.stream（）.filter（entry->entry.getValue（）.isJsonObject（））.forEach（entry->parseAllKeys（key，（JsonObject）entry.getValue（））；
object.entrySet（）.stream（）.filter（entry->entry.getValue（）.isJsonArray（））.forEach（entry->entry.getValue（）.getAsJsonArray（）.forEach（subEntry->parseallkey（key，（JsonObject）subEntry））；
}
}

导入org.json.JSONArray；
导入组织
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

import java.util.HashSet;
import java.util.Set;

public class GetKeys {
    public static void main(String[] args) {
        String jsonString = "{\"per_page\": 3,\"total\": 12,\"data\": [{\"color\": \"#98B2D1\",\"year\": 2000,\"name\": \"cerulean\",\"id\": 1,\"pantone_value\": \"15-4020\" }, {\"color\": \"#C74375\",\"year\": 2001,\"name\": \"fuchsia rose\",\"id\": 2,\"pantone_value\": \"17-2031\" }], \"page\": 1,\"total_pages\": 4 }\r\n";
        JsonParser parser = new JsonParser();
        JsonObject object = (JsonObject) parser.parse(jsonString);
        Set<String> keys = new HashSet<>();

        parseAllKeys(keys, object);

        keys.forEach(System.out::println);
    }

    private static void parseAllKeys(Set<String> keys, JsonObject object) {
        keys.addAll(object.keySet());
        object.entrySet().stream().filter(entry -> entry.getValue().isJsonObject()).forEach(entry -> parseAllKeys(keys, (JsonObject) entry.getValue()));
        object.entrySet().stream().filter(entry -> entry.getValue().isJsonArray()).forEach(entry -> entry.getValue().getAsJsonArray().forEach(subEntry -> parseAllKeys(keys, (JsonObject) subEntry)));
    }
}

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class MyClass
{
    public static ArrayList<String> keylist = new ArrayList<String>();
    public static void main(String args[]) throws JSONException
    {
        myfunction(myjson);
        System.out.println(keylist);
    }

    public static void myfunction(JSONObject x) throws JSONException
    {
        JSONArray keys =  x.names();
        for(int i=0;i<keys.length();i++)
        {
            String current_key = keys.get(i).toString();   
            if( x.get(current_key).getClass().getName().equals("org.json.JSONObject"))
            {
                keylist.add(current_key);
                myfunction((JSONObject) x.get(current_key));
            } 
            else if( x.get(current_key).getClass().getName().equals("org.json.JSONArray"))
            {
                for(int j=0;j<((JSONArray) x.get(current_key)).length();j++)
                {
                    if(((JSONArray) x.get(current_key)).get(j).getClass().getName().equals("org.json.JSONObject"))
                    {
                        keylist.add(current_key);
                        myfunction((JSONObject)((JSONArray) x.get(current_key)).get(j));
                    }
                }
            }
            else 
            {
                keylist.add(current_key);
            }
        }
    }
}

public JsonArray parseArrayKeysToLower(JsonArray arrRequest) {
    JsonArray arrayTemp = new JsonArray();
    for(int i = 0; i < arrRequest.size(); i++) {
      if (arrRequest.getValue(i) instanceof JsonObject) {
        arrayTemp.add(parseObjectKeysToLower((JsonObject) arrRequest.getValue(i)));
      } else if (arrRequest.getValue(i) instanceof JsonArray) {
        arrayTemp.add(parseArrayKeysToLower((JsonArray) arrRequest.getValue(i)));
      } else {
        arrayTemp.add(arrRequest.getValue(i));
      }
    }
    return arrayTemp;
  }

  public JsonObject parseObjectKeysToLower(JsonObject request) {
    JsonObject requestToLower = new JsonObject();
    try {
      request.forEach(e -> {
        String key = e.getKey();
        if (e.getValue() instanceof JsonObject) {
          requestToLower.put(key.toLowerCase(), parseObjectKeysToLower((JsonObject) e.getValue()));
        } else if (e.getValue() instanceof JsonArray) {
          requestToLower.put(key.toLowerCase(), parseArrayKeysToLower((JsonArray) e.getValue()));
        } else {
          requestToLower.put(key.toLowerCase(), e.getValue());
        }
      });
    } catch (Exception e) {
      e.printStackTrace();
    }
    return requestToLower;
  }