Java 使用Gson使用嵌套数组解析Json

我还没有在web上看到（已回答的）讨论这种嵌套json数组的示例

要分析的JSON：

{
    "Field": {
        "ObjectsList": [
            {
                "type": "Num",
                "priority": "Low",
                "size": 3.43
            },
            {
                "type": "Str",
                "priority": "Med",
                "size": 2.61
            }
        ]
    }
}

我为嵌套json块的每个“级别”创建了一个类。我希望能够解析“ObjectList”数组的内容

有人能帮我用Java中的Gson解析这个JSON吗？ 任何提示或代码片段都将不胜感激

我的做法如下：

public static void main (String... args) throws Exception 
{
    URL jsonUrl = new URL("http://jsonUrl.com") // cannot share the url
    try (InputStream input = jsonUrl.openStream(); 
         BufferedReader buffReader = new BufferedReader (new InputStreamReader (input, "UTF-8"))) 
        {
         Gson gson = new GsonBuilder().create();
         ClassA classA = gson.fromJson(buffReader, ClassA.class);

         System.out.println(classA);
        }
    }
}


class ClassA 
{
    private String field;
    // getter & setter //
}

class ClassB
{
    private List<ClassC> objList;
    // getter & setter //
}

clas ClassC
{
    private String type;
    private String priority;
    private double size;
    // getters & setters //

    public String printStr()
    {
        return String.format(type, priority, size);
    }
}

publicstaticvoidmain（String…args）引发异常
{
URL jsonUrl=新URL（“http://jsonUrl.com“”//无法共享该url
try（InputStream input=jsonUrl.openStream（）；
BufferedReader buffReader=新的BufferedReader（新的InputStreamReader（输入，“UTF-8”））
{
Gson Gson=new GsonBuilder（）.create（）；
ClassA ClassA=gson.fromJson（buffReader，ClassA.class）；
系统输出打印LN（A类）；
}
}
}
甲级
{
私有字符串字段；
//吸气剂和塞特//
}
B类
{
私有列表对象列表；
//吸气剂和塞特//
}
C类
{
私有字符串类型；
私有字符串优先级；
私人双户型；
//接球手和接球手//
公共字符串printStr（）
{
返回字符串。格式（类型、优先级、大小）；
}
}

以下代码片段和源文件将帮助您：

private static ParseResult NO_LINKS=new ParseResult（new HashSet（），0）；
私有JsonParser解析器；
公共静态void main（字符串[]s）引发IOException{
BufferedReader reader=新的BufferedReader（新的文件读取器[0]）；
MetadataTotlLinks MetadataTotlLinks=新MetadataTotlLinks（）；
while（reader.ready（））{
字符串[]字段=reader.readLine（）.split（“\t”）；
ParseResult outboundLinks=MetadataTotlLinks.outboundLinks（字段[1]）；
System.out.println（tldOf（字段[0]）+“”+outboundLinks.links）；
}
}
公共元数据totllinks（）{
this.parser=新的JsonParser（）；
}
公共ParseResult外部链接（字符串jsonMetaData）{
JsonObject元数据=parser.parse（jsonMetaData.toString（））.getAsJsonObject（）；
if（！“SUCCESS”.equals（metaData.get（“disposition”）.getAsString（））
不返回任何链接；
JsonElement content=metaData.get（“content”）；
if（content==null）
不返回任何链接；
JsonArray links=content.getAsJsonObject（）.getAsJsonArray（“links”）；
if（links==null）
不返回任何链接；
Set outboundLinks=new HashSet（）；
int numNull=0；
用于（JsonElement链接：链接）{
JsonObject link=linke.getAsJsonObject（）；
if（“a”.equals（link.get（“type”）.getAsString（））{//anchor
字符串tld=tldOf（link.get（“href”）.getAsString（））；
如果（tld==null）
++努努尔；
其他的
添加（tld）；
}
}
返回新的解析结果（outboundLinks，numNull）；
}
公共静态字符串tldOf（字符串url）{
试一试{
字符串tld=新URI（url）.getHost（）；
如果（tld==null）
返回null；
如果（tld.startsWith（“www.”）
tld=tld.子串（4）；
tld=tld.trim（）；
返回tld.length（）==0？null:tld；
}
捕获（URISyntaxException e）{
返回null；
}
}
公共静态类解析结果{
公共最终设置链接；
公共最终国际货币基金组织；
公共解析结果（设置链接，整数）{
this.links=链接；
this.numNull=numNull；
}
}

这个怎么样

if（json.isJsonArray（））{
JsonArray数组=json.getAsJsonArray（）；
List out=Lists.newArrayListWithCapacity（array.size（））；
用于（JsonElement项：数组）{
增加（toRawTypes（项目））；
}
}

private static ParseResult NO_LINKS = new ParseResult(new HashSet<String>(), 0);
  private JsonParser parser;

  public static void main(String[] s) throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader(s[0]));
    MetaDataToTldLinks metaDataToTldLinks = new MetaDataToTldLinks();
    while (reader.ready()) {
      String[] fields = reader.readLine().split("\t");
      ParseResult outboundLinks = metaDataToTldLinks.outboundLinks(fields[1]);
      System.out.println(tldOf(fields[0]) + " " + outboundLinks.links);      
    }
  }

  public MetaDataToTldLinks() {
    this.parser = new JsonParser();
  }

  public ParseResult outboundLinks(String jsonMetaData) {
    JsonObject metaData = parser.parse(jsonMetaData.toString()).getAsJsonObject();

    if (!"SUCCESS".equals(metaData.get("disposition").getAsString()))
      return NO_LINKS;

    JsonElement content = metaData.get("content");
    if (content == null)
      return NO_LINKS;

    JsonArray links = content.getAsJsonObject().getAsJsonArray("links");
    if (links == null)
      return NO_LINKS;

    Set<String> outboundLinks = new HashSet<String>();
    int numNull = 0;
    for (JsonElement linke : links) {
      JsonObject link = linke.getAsJsonObject();
      if ("a".equals(link.get("type").getAsString())) { // anchor        
        String tld = tldOf(link.get("href").getAsString());
        if (tld == null)
          ++numNull;
        else
          outboundLinks.add(tld);
      }
    }
    return new ParseResult(outboundLinks, numNull);

  }

  public static String tldOf(String url) {
    try {
      String tld = new URI(url).getHost();
      if (tld==null)
          return null;
      if (tld.startsWith("www."))
        tld = tld.substring(4);
      tld = tld.trim();
      return tld.length()==0 ? null : tld;
    }
    catch (URISyntaxException e) {
      return null;
    }
  }

  public static class ParseResult {
    public final Set<String> links;
    public final int numNull;
    public ParseResult(Set<String> links, int numNull) {
      this.links = links;
      this.numNull = numNull;
    }
  }

if (json.isJsonArray()) {
  JsonArray array = json.getAsJsonArray();
  List<Object> out = Lists.newArrayListWithCapacity(array.size());
  for (JsonElement item : array) {
    out.add(toRawTypes(item));
   }
}