0

我需要大约。来自提供的包含 100 多个键的数据中的 20 个键。

Set<Entry<Double,PosTvector>> set = realPosDataMap.entrySet();

Iterator<Entry<Double, PosTvector>> i1 = set.iterator();

Map.Entry<Double,PosTvector> map;

while(i1.hasNext()) {
    map = i1.next();

    Double xvalue = map.getKey();
    PosTvector yvalue = map.getValue();
    PosTvector yvalue1 = map.getValue();
    PosTvector yvalue2 = map.getValue();                       
    Data<String, Number> data = new Data<String, Number>(xvalue.toString(), yvalue.state[0]);
    Data<String, Number> data1 = new Data<String, Number>(xvalue.toString(), yvalue1.state[1]);
    Data<String, Number> data2 = new Data<String, Number>(xvalue.toString(), yvalue2.state[2]);
  //Data<String, Number> verticalMarker = new Data<String, Number>(xvalue.toString(), 0);

    series.getData().add(data);   
    series1.getData().add(data1); 
    series2.getData().add(data2);


}   
series.setName("X-Position");
series1.setName("Y-Position");
series2.setName("Z-Position");


lineChart.getData().addAll(series, series1, series2);

我想在折线图上仅显示 20 个键和值，而不是图表上的所有 100 个值。你能帮帮我吗，我们怎样才能做到这一点？提前致谢。

4

2 回答 2

0

我不知道我理解得很好，所以当你想要抽取数据时，我会谈谈这种情况。

最好的解决方案是重新采样您的输入数据和时间向量。

但如果你想简单一点，你可以尝试这样的事情：

  • 始终添加起始结束数据点
  • 对于内部数据点，计算抽取

例子

此示例将始终生成LineChart具有 20 个节点的 a，与您输入数组具有多少数据点无关。

注意：这个解决方案远不是你能拥有的最好的，并且严重依赖于输入数据向量具有相同的时间向量。时间向量的步长固定也影响结果。

public class ChartingApp extends Application {

    @Override
    public void start(Stage stage) throws Exception {

        final NumberAxis xAxis = new NumberAxis();
        final NumberAxis yAxis = new NumberAxis();
        final LineChart<Number, Number> lineChart = new LineChart<Number, Number>(xAxis, yAxis);

        // Size of the input data
        int dataCount = 777;

        // One X axis two Y axis
        double[] xValues = new double[dataCount];
        double[] y1Values = new double[dataCount];
        double[] y2Values = new double[dataCount];

        // Generate some initial data
        Random randomGenerator = new Random();

        for (int i = 0; i < dataCount; i++) {
            xValues[i] = i;
            y1Values[i] = randomGenerator.nextInt(200);
            y2Values[i] = randomGenerator.nextInt(200);
        }

        // Amount of nodes to display
        int valueCountToDisplay = 20;

        Series<Number, Number> series1 = new Series<Number, Number>();
        Series<Number, Number> series2 = new Series<Number, Number>();

        // The first element is always added
        series1.getData().add(new Data<Number, Number>(xValues[0], y1Values[0]));
        series2.getData().add(new Data<Number, Number>(xValues[0], y2Values[0]));

        // Generate the inner nodes
        double elementToPick = Math.floor((dataCount - 2) / (valueCountToDisplay - 2));

        for (int i = 1; i < dataCount - 1; i++) {
            if (i % elementToPick == 0) {
                series1.getData().add(new Data<Number, Number>(xValues[i], y1Values[i]));
                series2.getData().add(new Data<Number, Number>(xValues[i], y2Values[i]));
            }
        }

        // The last element is always added
        series1.getData().add(new Data<Number, Number>(xValues[dataCount - 1], y1Values[dataCount - 1]));
        series2.getData().add(new Data<Number, Number>(xValues[dataCount - 1], y2Values[dataCount - 1]));

        Scene scene = new Scene(lineChart, 800, 600);
        lineChart.getData().addAll(series1, series2);

        stage.setScene(scene);
        stage.show();

    }

    public static void main(String[] args) {
        launch(args);
    }

}

结果是：

在此处输入图像描述

背后的逻辑可以总结如下：

double[] createSparseArray(double[] inputData, int arraySize) {
    List<Double> sparseList = new ArrayList<Double>();

    sparseList.add(inputData[0]);

    double elementToPick = Math.floor((inputData.length - 2) / (arraySize - 2));

    for (int i = 1; i < inputData.length - 1; i++) {
        if (i % elementToPick == 0)
            sparseList.add(inputData[i]);
    }
    sparseList.add(inputData[arraySize - 1]);
    return sparseList.stream().mapToDouble(d -> d).toArray();
}

该示例使用数组来存储数据，但它与您的数据结构非常相似（使用size ofSet并使用旧的 for 循环进行循环）。

于 2016-06-20T10:13:22.177 回答
0

好吧，只需创建一个在每次迭代中增加的新变量。当这个变量的值达到 20 时，跳出循环。像这样：

int amount = 0;
while(i1.hasNext()) {
    amount += 1;
    if(amount == 20) {
        break;
    }
    ...
}

如果您不知道break：它是离开包含循环的关键字。

编辑

我首先误解了你，这是（希望）正确的答案。而不是上面的解决方案，请执行以下操作：

while(i1.hasNext()) {
    map = i1.next();
    if(map.getKey() > 20 || map.getKey() < 1) {
        continue;
    }
    ...
}

此代码检查条目的键是否在 1 到 20 之间。如果不是，将检查下一个条目。为此，它使用continue- 一个类似于 的关键字break，但它不会结束循环，而是跳转到下一次迭代。

于 2016-06-20T11:29:54.723 回答