guava 테이블 값을 Java 파일의 파일로 작성

Question

Guava 테이블을 파일로 작성하는 방법은 무엇입니까? 이 작업을 수행하는 가장 좋은 방법은 무엇입니까? 테이블에서 값이 어떻게 보이는지는 중요하지 않습니다. 내 주요 목표는 테이블을 작성하고 읽는 것입니다.

Answer 1

지속성을 위해 테이블을 모델링하는 데는 여러 가지 방법이 있으며, 다른 유형의 테이블 (예 : 밀도 대 구문 분석, 배열 테이블 대 트리 기반 테이블 등)에 따라 다른 접근 방법이 더 좋습니다. 일반적인 목적

(즉, 테이블의 특정 유형에 최적화되지 않음) 아마 다음을 계속 것 :

1. 행 키
2. 열 키 배열의 배열
3. 각각의 셀은 다음을 포함 셀의 어레이 :
   1. 로우 키 배열의 로우 키의 인덱스
   2. 공업

      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(); 
          } 
      } 
      

      사용 : 열 키

   3. 가 google/gson: A Java serialization/deserialization library that can convert Java Objects into JSON and back.

      예를 사용하여 이러한 달성 할 점에 유의 값

들의 어레이에서의 열 키 전 :

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" 
    } 
    ] 
}