Java ArrayTable类代码示例

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
private static void loadFromDb(ArrayTable<Integer, Character, List<Person>> personsTable) throws IOException {
    long start = System.currentTimeMillis();

    File dbFile = new File(Config.DB_FILE_NAME);
    LineIterator it = FileUtils.lineIterator(dbFile, "UTF-8");
    while(it.hasNext()) {
        String line = it.next();
        Person person = parseStringTokenizer(line);
        char fc = person.name.charAt(0);
        List<Person> persons = personsTable.get(person.age, fc);
        if(persons == null) {
            persons = new ArrayList<>();
            personsTable.put(person.age, person.name.charAt(0), persons);
        }
        persons.add(person);
    }
    System.out.println("load data elapsed time : " + (System.currentTimeMillis() - start));
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
private MLDouble histoDataAsMLDouble(String name, ArrayTable<Integer, String, Float> histoData) {
    int rowsSize = histoData.rowKeySet().size();
    int colsSize = histoData.columnKeySet().size();
    MLDouble mlDouble = new MLDouble(name, new int[] {rowsSize, colsSize});
    int i = 0;
    for (Integer rowKey : histoData.rowKeyList()) {
        int j = 0;
        for (String colkey : histoData.columnKeyList()) {
            Float v = histoData.get(rowKey, colkey);
            mlDouble.set(new Double(v), i, j);
            j++;
        }
        i++;
    }
    return mlDouble;
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
public static double[][] histoDataAsDoubleMatrixNew(ArrayTable<Integer, String, Float> hdTable) {
    int rowsSize = hdTable.rowKeySet().size();
    int colsSize = hdTable.columnKeySet().size();
    double[][] matFinal = new double[rowsSize][colsSize];
    int i = 0;
    for (Integer rowKey : hdTable.rowKeyList()) {
        int j = 0;
        for (String colkey : hdTable.columnKeyList()) {
            Float v = hdTable.get(rowKey, colkey);
            matFinal[i][j] = getCleanFloat(v);
            j = j + 1;
        }
        i = i + 1;
    }
    return matFinal;
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
private Table<String, ResourceType, Response<Map<String, String>>> getAllFromRedis(Set<String> userIds) {
  if (userIds.size() == 0) {
    return HashBasedTable.create();
  }
  try (Jedis jedis = jedisSource.getJedis()) {
    Table<String, ResourceType, Response<Map<String, String>>> responseTable =
        ArrayTable.create(userIds, new ArrayIterator<>(ResourceType.values()));

    Pipeline p = jedis.pipelined();
    for (String userId : userIds) {
      for (ResourceType r : ResourceType.values()) {
        responseTable.put(userId, r, p.hgetAll(userKey(userId, r)));
      }
    }
    p.sync();
    return responseTable;
  } catch (Exception e) {
    log.error("Storage exception reading all entries.", e);
  }
  return null;
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
public  GridImageData(String fileName, String dataUrl,int gridSize,int row,int col,int imageWidth,int imageHeight) {
	super();
	this.fileName = fileName;
	this.dataUrl = dataUrl;
	this.gridSize=gridSize;
	this.row=row;
	this.col=col;
	this.imageHeight=imageHeight;
	this.imageWidth=imageWidth;
	
	
	Collection<Integer> rowValues=new ArrayList<Integer>();
	Collection<Integer> colValues=new ArrayList<Integer>();
	for(int i=0;i<row;i++){
		rowValues.add(i);
	}
	for(int i=0;i<col;i++){
		colValues.add(i);
	}
	gridTable=ArrayTable.create(rowValues, colValues);
	
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
private static void arrayTable() throws IOException {
       List<Integer> ages = new ArrayList<>();
       for(int i = 1; i <= 18; i++) {
           ages.add(i);
       }

       String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
       List<Character> chapters = new ArrayList<>();
       for(int i = 0; i < str.length(); i++) {
           chapters.add(str.charAt(i));
       }

       ArrayTable<Integer, Character, List<Person>> personsTable = ArrayTable.create(ages, chapters);
	loadFromDb(personsTable);

       for(char c = 'a'; c <= 'e'; c++) {
           Map<Integer, List<Person>> rowsPerson = personsTable.column(c);
           long count6_11 = rowsPerson.keySet()
                   .stream()
                   .filter(r -> r >= 6 && r <= 11)
                   .map(r -> rowsPerson.get(r).size()).reduce(0, Integer::sum);
           System.out.println("[6-11]-" + c + " : " + count6_11);

           long count16_18 = rowsPerson.keySet()
                   .stream()
                   .filter(r -> r >= 16 && r <= 18)
                   .map(r -> rowsPerson.get(r).size()).reduce(0, Integer::sum);
           System.out.println("[16-18]-" + c + " : " + count16_18);
       }

}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
public ForecastErrorsHistoricalData(List<String> generatorsIds, List<String> loadsIds,
                                    List<StochasticVariable> stochasticVariables,
                                    ArrayTable<Integer, String, Float> forecastsData,
                                    ArrayTable<Integer, String, Float> snapshotsData) {
    this.generatorsIds = generatorsIds;
    this.loadsIds = loadsIds;
    this.stochasticVariables = stochasticVariables;
    this.forecastsData = forecastsData;
    this.snapshotsData = snapshotsData;
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
public Wp41HistoData(List<String> historicalGensIds,
                     List<String> historicalLoadsIds,
                     List<String> historicalDanglingLinesIds,
                     ArrayTable<Integer, String, Float> hdTable) {
    this.historicalGensIds = historicalGensIds;
    this.historicalLoadsIds = historicalLoadsIds;
    this.historicalDanglingLinesIds = historicalDanglingLinesIds;
    this.hdTable = hdTable;
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
private Wp41HistoData parseData(DataMiningFacadeParams dmParams) throws IOException, InterruptedException {
    int rowCount = histoClient.queryCount(dmParams.getInterval(), HistoDbHorizon.SN);

    Set<HistoDbAttributeId> attributeIds = new LinkedHashSet<>((dmParams.getGensIds().size() +
                                                                dmParams.getLoadsIds().size() +
                                                                dmParams.getDanglingLinesIds().size()) * 2); // gens P, Q loads P, Q danglingLines P0, Q0
    for (String genId : dmParams.getGensIds()) {
        attributeIds.add(new HistoDbNetworkAttributeId(genId, HistoDbAttr.P));
        attributeIds.add(new HistoDbNetworkAttributeId(genId, HistoDbAttr.Q));
    }
    for (String loadId : dmParams.getLoadsIds()) {
        attributeIds.add(new HistoDbNetworkAttributeId(loadId, HistoDbAttr.P));
        attributeIds.add(new HistoDbNetworkAttributeId(loadId, HistoDbAttr.Q));
    }
    for (String dlId : dmParams.getDanglingLinesIds()) {
        attributeIds.add(new HistoDbNetworkAttributeId(dlId, HistoDbAttr.P0));
        attributeIds.add(new HistoDbNetworkAttributeId(dlId, HistoDbAttr.Q0));
    }

    List<Integer> rowIndexes;
    try (IntStream intStream = IntStream.range(0, rowCount)) {
        rowIndexes = intStream.boxed().collect(Collectors.toList());
    }
    List<String> colIndexes = attributeIds.stream().map(Object::toString).collect(Collectors.toList());

    ArrayTable<Integer, String, Float> hdTable = ArrayTable.create(rowIndexes, colIndexes);

    // parse csv generators
    try (InputStream is = histoClient.queryCsv(HistoQueryType.data, attributeIds, dmParams.getInterval(), HistoDbHorizon.SN, false, false)) {
        parseCsv(is, attributeIds, hdTable, rowCount);
    }

    return new Wp41HistoData(dmParams.getGensIds(), dmParams.getLoadsIds(), dmParams.getDanglingLinesIds(), hdTable);
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
public static double[][] histoDataAsDoubleMatrix(ArrayTable<Integer, String, Float> hdTable) {

        int rowsSize = hdTable.rowKeySet().size();
        int colsSize = hdTable.columnKeySet().size();
        double[][] matFinal = new double[rowsSize][colsSize];
        for (int i = 0; i < rowsSize; i++) {
            for (int j = 0; j < colsSize; j++) {
                Float v = hdTable.get(i, j);
                matFinal[i][j] = getCleanFloat(v);
            }
        }
        return matFinal;
    }
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
/**
 * Parses a HOCON config to a table of network rules.
 */
private static Table<Direction, AccessType, Iterable<NetworkRule>> parse(Config config) {
  Table<Direction, AccessType, Iterable<NetworkRule>> rules =
      ArrayTable.create(EnumSet.allOf(Direction.class), EnumSet.allOf(AccessType.class));
  for (Direction direction: Direction.values()) {
    for (AccessType access: AccessType.values()) {
      populateRules(config, direction, access, rules);
    }
  }
  return rules;
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
/**
 * Builds a {@link ScenarioResultModel} from the data calculated in a single cycle.
 * @param resultModel the results calculated by the engine in a single calculation cycle
 * @param columnNames column name overrides
 * @return A simple result model built from the results
 * @throws IllegalArgumentException if the number of column names doesn't match the number of columns
 */
public SimpleResultModel build(ViewResultModel resultModel, List<String> columnNames) {
  ArgumentChecker.notNull(columnNames, "columnNames");
  ArgumentChecker.notNull(resultModel, "resultModel");

  if (columnNames.size() != _columnNames.size()) {
    throw new IllegalArgumentException("Wrong number of column names. expected: " + _columnNames.size() +
                                           ", actual: " + columnNames.size());
  }
  int rowCount = _idToIndex.size();
  int colCount = columnNames.size();
  ContiguousSet<Integer> rowIndices = ContiguousSet.create(Range.closedOpen(0, rowCount), DiscreteDomain.integers());
  ContiguousSet<Integer> colIndices = ContiguousSet.create(Range.closedOpen(0, colCount), DiscreteDomain.integers());
  Table<Integer, Integer, Object> table = ArrayTable.create(rowIndices, colIndices);

  for (ViewResultEntry entry : resultModel.getAllResults()) {
    String calcConfigName = entry.getCalculationConfiguration();
    ComputedValueResult value = entry.getComputedValue();
    ValueSpecification valueSpec = value.getSpecification();
    CompiledViewCalculationConfiguration calcConfig = _compiledViewDef.getCompiledCalculationConfiguration(calcConfigName);
    Set<ValueRequirement> valueReqs = calcConfig.getTerminalOutputSpecifications().get(valueSpec);

    for (ValueRequirement valueReq : valueReqs) {
      ColumnSpec colSpec = new ColumnSpec(calcConfigName, valueReq.getValueName(), valueReq.getConstraints());
      Integer colIndex = _colToIndex.get(colSpec);
      Integer rowIndex = _idToIndex.get(valueReq.getTargetReference().getSpecification().getUniqueId().getObjectId());

      // there won't be a row or column index for specific outputs (e.g. curves)
      if (colIndex != null && rowIndex != null) {
        table.put(rowIndex, colIndex, value);
      }
      // TODO handle specific outputs
    }
  }
  return new SimpleResultModel(_targets, columnNames, table, resultModel.getViewCycleExecutionOptions());
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
StateMachineServiceBuilder(@NonNull final Class<S> states, @NonNull final Class<E> events) {
	stateClass = requireNonNull(states);
	eventClass = requireNonNull(events);

	transitions = ArrayTable.create(EnumSet.allOf(stateClass), EnumSet.allOf(eventClass));
	actions = ArrayTable.create(EnumSet.allOf(stateClass), EnumSet.allOf(eventClass));

	noStateTransitions = newEnumMap(eventClass);
	noStateActions = newEnumMap(eventClass);
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
public AggregateTrialReport(boolean showOutcomeNames,
    boolean showAttributeNames, boolean outcomesAreRows,
    List<SimulationInputs> simulationInputs, int numTrialsPerSimulation) {
  this.showAttributeNames = showAttributeNames;
  this.showOutcomeNames = showOutcomeNames;
  this.outcomesAreRows = outcomesAreRows;
  List<Integer> columns = Lists.newArrayList();
  for (int i = 0; i < numTrialsPerSimulation; i++) {
    columns.add(i);
  }
  trialOutcomes = ArrayTable.create(simulationInputs, columns);
  nodeAggregationAttributes = Lists.newArrayList();
}
 

import com.google.common.collect.ArrayTable; //导入依赖的package包/类
public void getColumnTypes() {
  ArrayTable<Integer, Integer, Result<?>> table = ArrayTable.create(INDICES, INDICES);
  table.put(0, 0, Result.success(1));
  table.put(0, 1, Result.success("abc"));
  table.put(1, 0, Result.success(2));
  table.put(1, 1, Result.success("def"));

  List<Class<?>> columnTypes = TradeReportFormatter.INSTANCE.getColumnTypes(report(table));
  assertThat(columnTypes).isEqualTo(ImmutableList.of(Integer.class, String.class));
}