Использование GSON для анализа массива с несколькими типами

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 десериализовать первый пример как тип Object. Object data = 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<List<String, int, List<int>>>, но это невозможно определить в Java. Итак, вы должны довольствоваться List<List<String>> (or String[][]) или обратиться к подходу с более "ручным" разбором.

(Да, Java допускает объявление типа List<List<Object>>, но Object не является достаточно специфичным типом для осмысленной десериализации. Кроме того, как обсуждалось, попытка десериализации [3] в Object приводит к исключению синтаксического анализа.)

Небольшое обновление: недавно мне пришлось десериализовать какой-то небрежный 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);
  }
}

В руководстве пользователя Gson рассматривается обработка десериализации коллекций смешанных типов на примере, аналогичном приведенному в раздел "Сериализация и десериализация коллекции с объектами произвольных типов".

Во-первых, я думаю, что вы можете ошибиться в своем примере выше. Массив, состоящий из трех разных, — это очень необычный подход, если не сказать больше. Вероятно, ваша структура json представляет собой массив, содержащий кортежи. Затем эти кортежи включают массив.

Нравиться:

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

XXX должен быть объектом, содержащим:

Строка

int (или целое число)

Массив (я думаю) целых чисел.

Затем вы создаете массив этих объектов и анализируете в нем json.

Однако ваш json кажется действительно плохо сформированным, так как все члены должны быть названы, например

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

Если, с другой стороны, JSON действительно выглядит так, как вы его описываете, вам придется создавать массивы Object, простые и простые, а затем приводить их, когда вы читаете их из своей структуры данных.