在Java中將番石榴表值寫入文件

Question

如何將Guava表寫入文件？ 最好的方法是什么？ 表中的值看起來如何並不重要。 我的主要目的是寫作和閱讀表。

Answer 1

有多種為持久性建模表的方法，不同的方法對於不同類型的表（例如，密集表與解析表，數組表與基於樹的表等）更好。

出於一般目的（即未針對任何特定類型的表進行優化），我可能會堅持以下做法：

1. 行鍵的數組
2. 列鍵的數組
3. 單元格數組，其中每個單元格包含以下內容：
   1. 行鍵在行鍵數組中的索引
   2. 列鍵在列鍵數組中的索引
   3. 價值

考慮到這一點，您可以使用google / gson完成此任務：Java序列化/反序列化庫，可以將Java對象轉換為JSON並返回。

例：

class TableTypeHierarchyAdapter<R, C, V> implements JsonSerializer<Table<R, C, V>>, JsonDeserializer<Table<R, C, V>> {
    @Override
    public JsonElement serialize(Table<R, C, V> src, Type typeOfSrc, JsonSerializationContext context) {
        JsonArray rowKeysJsonArray = new JsonArray();
        Map<R, Integer> rowKeyToIndex = new HashMap<>();
        for (R rowKey : src.rowKeySet()) {
            rowKeyToIndex.put(rowKey, rowKeyToIndex.size());
            rowKeysJsonArray.add(context.serialize(rowKey));
        }
        JsonArray columnKeysJsonArray = new JsonArray();
        Map<C, Integer> columnKeyToIndex = new HashMap<>();
        for (C columnKey : src.columnKeySet()) {
            columnKeyToIndex.put(columnKey, columnKeyToIndex.size());
            columnKeysJsonArray.add(context.serialize(columnKey));
        }
        JsonArray cellsJsonArray = new JsonArray();
        for (Table.Cell<R, C, V> cell : src.cellSet()) {
            JsonObject cellJsonObject = new JsonObject();
            int rowIndex = rowKeyToIndex.get(cell.getRowKey());
            int columnIndex = columnKeyToIndex.get(cell.getColumnKey());
            cellJsonObject.addProperty("rowIndex", rowIndex);
            cellJsonObject.addProperty("columnIndex", columnIndex);
            cellJsonObject.add("value", context.serialize(cell.getValue()));
            cellsJsonArray.add(cellJsonObject);
        }
        JsonObject tableJsonObject = new JsonObject();
        tableJsonObject.add("rowKeys", rowKeysJsonArray);
        tableJsonObject.add("columnKeys", columnKeysJsonArray);
        tableJsonObject.add("cells", cellsJsonArray);
        return tableJsonObject;
    }

    @Override
    public Table<R, C, V> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {
        Type typeOfR;
        Type typeOfC;
        Type typeOfV;
        {
            ParameterizedType parameterizedType = (ParameterizedType) typeOfT;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            typeOfR = actualTypeArguments[0];
            typeOfC = actualTypeArguments[1];
            typeOfV = actualTypeArguments[2];
        }
        JsonObject tableJsonObject = json.getAsJsonObject();
        JsonArray rowKeysJsonArray = tableJsonObject.getAsJsonArray("rowKeys");
        Map<Integer, R> rowIndexToKey = new HashMap<>();
        for (JsonElement jsonElement : rowKeysJsonArray) {
            R rowKey = context.deserialize(jsonElement, typeOfR);
            rowIndexToKey.put(rowIndexToKey.size(), rowKey);
        }
        JsonArray columnKeysJsonArray = tableJsonObject.getAsJsonArray("columnKeys");
        Map<Integer, C> columnIndexToKey = new HashMap<>();
        for (JsonElement jsonElement : columnKeysJsonArray) {
            C columnKey = context.deserialize(jsonElement, typeOfC);
            columnIndexToKey.put(columnIndexToKey.size(), columnKey);
        }
        JsonArray cellsJsonArray = tableJsonObject.getAsJsonArray("cells");
        ImmutableTable.Builder<R, C, V> builder = ImmutableTable.builder();
        for (JsonElement jsonElement : cellsJsonArray) {
            JsonObject cellJsonObject = jsonElement.getAsJsonObject();
            int rowIndex = cellJsonObject.get("rowIndex").getAsInt();
            int columnIndex = cellJsonObject.get("columnIndex").getAsInt();
            R rowKey = rowIndexToKey.get(rowIndex);
            C columnKey = columnIndexToKey.get(columnIndex);
            V value = context.deserialize(cellJsonObject.get("value"), typeOfV);
            builder.put(rowKey, columnKey, value);
        }
        return builder.build();
    }
}

用法：

Table<String, String, String> table = ImmutableTable.<String, String, String>builder()
        .put("R1", "C1", "R1C1")
        .put("R1", "C2", "R1C2")
        .put("R2", "C1", "R2C1")
        .put("R2", "C2", "R2C2")
        .build();
Gson gson = new GsonBuilder()
        .setPrettyPrinting()
        .registerTypeHierarchyAdapter(Table.class, new TableTypeHierarchyAdapter())
        .create();
try (FileWriter writer = new FileWriter("table.json")) {
    gson.toJson(table, writer);
}
try (FileReader reader = new FileReader("table.json")) {
    Type typeOfTable = new TypeToken<Table<String, String, String>>() {}.getType();
    Table<String, String, String> readTable = gson.fromJson(reader, typeOfTable);
    assert table.equals(readTable);
}

table.json：

{
  "rowKeys": [
    "R1",
    "R2"
  ],
  "columnKeys": [
    "C1",
    "C2"
  ],
  "cells": [
    {
      "rowIndex": 0,
      "columnIndex": 0,
      "value": "R1C1"
    },
    {
      "rowIndex": 0,
      "columnIndex": 1,
      "value": "R1C2"
    },
    {
      "rowIndex": 1,
      "columnIndex": 0,
      "value": "R2C1"
    },
    {
      "rowIndex": 1,
      "columnIndex": 1,
      "value": "R2C2"
    }
  ]
}