Java 使用GSON解析具有多种类型的数组

我希望使用GSON解析以下json：

[
    [
        "hello",
        1,
        [2]
    ],
    [
        "world",
        3,
        [2]
    ]
]

这是一个数组，包含两个数组。这两个内部数组本身就是数组，由字符串、int和数组类型组成

我不确定如何使用Java类对具有3种不同类型（String、int、array）的数组进行建模。我首先说：

// String json just contains the aforementioned json string.

ArrayList<ArrayList<XXX>> data = new ArrayList<ArrayList<XXX>>();

Type arrayListType = new TypeToken<ArrayList<ArrayList<XXX>>>(){}.getType();

data = gson.fromJson(json, arrayListType);

//字符串json只包含前面提到的json字符串。
ArrayList数据=新的ArrayList（）；
类型arrayListType=newTypeToken（）{}.getType（）；
data=gson.fromJson（json，arrayListType）；

但是“XXX”应该在哪里呢？我认为它应该是一个数组，但它应该是一个包含3种不同数据类型的数组。那么我如何使用Java来建模呢

能帮忙吗？

---

谢谢。

首先，我想你在上面的例子中可能弄错了。至少可以说，由三个不同的数组组成的数组是一种非常不寻常的方法。可能您的json结构是一个数组，包含元组。然后，这些元组包含一个数组

比如：

[
{
    "hello",
    1,
    [2]
},
{
    "world",
    3,
    [2]
}
]

XXX应该是包含以下内容的对象：

一串

整数（或整数）

（我猜）整数数组

然后创建这些对象的数组，并将json解析到其中

然而，您的json似乎格式非常糟糕，因为所有成员都应该命名，如

[
{
    "str":"hello",
    "intVal":1,
    "intArr":[2]
},
{
    "str":"world",
    "intVal":3,
    "intArr":[2]
}
]

---

另一方面，如果JSON真的与您描述它的方式一样，那么您必须创建简单明了的对象数组，然后在从数据结构中读取它们时强制转换它们

Gson对将一些单组件数组反序列化为非数组类型进行了特殊处理。例如，

int data=gson.fromJson（“[3]”，int.class）会将int值3分配给数据

当然，不需要将单个组件数组反序列化为非数组类型。例如，前面的示例可以反序列化为
int[]data=gson.fromJson（“[3]”，int[].class）

当被询问时，Gson还经常将非字符串值反序列化为字符串。将此应用于第一个示例，
String data=gson.fromJson（“[3]”，String.class）也同样有效

请注意，告诉Gson将第一个示例反序列化为type对象是行不通的<代码>对象数据=gson.fromJson（“[3]”，Object.class）导致解析异常，抱怨[3]不是原语

应用于上面原始问题中的示例，如果可以接受将所有值视为字符串，则反序列化变得简单

// output:
// hello 1 2 
// world 3 2 

public class Foo
{
  static String jsonInput = 
    "[" +
      "[\"hello\",1,[2]]," +
      "[\"world\",3,[2]]" +
    "]";

  public static void main(String[] args)
  {
    Gson gson = new Gson();
    String[][] data = gson.fromJson(jsonInput, String[][].class);
    for (String[] data2 : data)
    {
      for (String data3 : data2)
      {
        System.out.print(data3);
        System.out.print(" ");
      }
      System.out.println();
    }
  }
}

不幸的是，使用Gson，我无法找到一种简单的反序列化方法来允许“更好地”绑定到数组中更具体、更混合的类型，因为Java没有提供定义混合类型数组的语法。例如，原始问题中首选的集合类型可能是
List
，但在Java中无法定义。因此，您必须满足于
列表（或字符串[]]）
，或者转向一种更“手动”解析的方法

（是的，Java允许类型声明为
列表
，但
对象
不是一个足够具体的类型，无法对其进行有意义的反序列化。此外，如前所述，尝试将[3]反序列化为对象会导致解析异常。）


小更新：我最近不得不反序列化一些草率的JSON，其中包含一个与原始问题中的结构不太相似的结构。最后，我只是使用自定义反序列化程序从凌乱的JSON数组创建了一个对象。与下面的示例类似

// output: 
// [{MyThreeThings: first=hello, second=1, third=[2]}, 
//  {MyThreeThings: first=world, second=3, third=[4, 5]}]

import java.lang.reflect.Type;
import java.util.Arrays;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;

public class FooToo
{
  static String jsonInput =
      "[" +
          "[\"hello\",1,[2]]," +
          "[\"world\",3,[4,5]]" +
      "]";

  public static void main(String[] args)
  {
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeAdapter(MyThreeThings.class, new MyThreeThingsDeserializer());
    Gson gson = gsonBuilder.create();
    MyThreeThings[] things = gson.fromJson(jsonInput, MyThreeThings[].class);
    System.out.println(Arrays.toString(things));
  }
}

class MyThreeThings
{
  String first;
  int second;
  int[] third;

  MyThreeThings(String first, int second, int[] third)
  {
    this.first = first;
    this.second = second;
    this.third = third;
  }

  @Override
  public String toString()
  {
    return String.format(
        "{MyThreeThings: first=%s, second=%d, third=%s}",
        first, second, Arrays.toString(third));
  }
}

class MyThreeThingsDeserializer implements JsonDeserializer<MyThreeThings>
{
  @Override
  public MyThreeThings deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
      throws JsonParseException
  {
    JsonArray jsonArray = json.getAsJsonArray();
    String first = jsonArray.get(0).getAsString();
    int second = jsonArray.get(1).getAsInt();
    JsonArray jsonArray2 = jsonArray.get(2).getAsJsonArray();
    int length = jsonArray2.size();
    int[] third = new int[length];
    for (int i = 0; i < length; i++)
    {
      int n = jsonArray2.get(i).getAsInt();
      third[i] = n;
    }
    return new MyThreeThings(first, second, third);
  }
}

//输出：
//[{MyThreeThings:first=hello，second=1，third=2]}，
//{MyThreeThings:first=世界，second=3，third=[4,5]}]
导入java.lang.reflect.Type；
导入java.util.array；
导入com.google.gson.gson；
导入com.google.gson.GsonBuilder；
导入com.google.gson.JsonArray；
导入com.google.gson.JsonDeserializationContext；
导入com.google.gson.JsonDeserializer；
导入com.google.gson.JsonElement；
导入com.google.gson.JsonParseException；
公共类FooToo
{
静态字符串jsonInput=
"[" +
“[\'你好\'，1，[2]]，”+
“[\'world\'，3，[4,5]]”+
"]";
公共静态void main（字符串[]args）
{
GsonBuilder GsonBuilder=新的GsonBuilder（）；
gsonBuilder.registerTypeAdapter（MyThreeThings.class，新的MyThreeThingsDeserializer（））；
Gson-Gson=gsonBuilder.create（）；
MyThreeThings[]things=gson.fromJson（jsonInput，MyThreeThings[].class）；
System.out.println（array.toString（things））；
}
}
阶级神话
{
先串；
int秒；
int[]第三；
MyThreeThings（字符串第一，整数第二，整数[]第三）
{
this.first=first；
这个秒=秒；
这个。三分之一=三分之一；
}
@凌驾
公共字符串toString（）
{
返回字符串格式(
{MyThreeThings:first=%s，second=%d，third=%s}，
第一，第二，array.toString（第三）；
}
}
类MyThreeThingsDeserializer实现JsonDeserializer
{
@凌驾
公共Mystreethings反序列化（JsonElement json，类型typeOfT，JsonDeserializationContext）
抛出JsonParseException
{
JsonArray JsonArray=json.getAsJsonArray（）；
String first=jsonArray.get（0.getAsString（）；
int second=jsonArray.get（1.getAsInt（）；
JsonArray jsonArray2=JsonArray.get（2.getAsJsonArray（）；
int length=jsonArray2.size（）；
int[]第三个=新的int[长度]；
for（int i=0；i

Gson用户指南确实包含了处理混合类型集合的反序列化，示例与中类似。
这也正是我的想法……如果JSON的格式为：{“str”：“hello”，“intVal”：1，“intArr”：[2]}，那么我可以创建自己的类，对这些数据进行建模。不幸的是，数据真的是我发布的……因此我的问题和这篇文章：）