1

我正在使用 Java，我有一个 TimestampAndValue 类型的对象列表：

public class TimestampAndValue{
    private double value;
    private long timestamp;

    public long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(long timestamp) {
        this.timestamp = timestamp;
    }

    public double getValue() {
        return value;
    }

    public void setValue(double value) {
        this.value = value;
    }
}

我的清单与此类似：

  • 元素 1：时间戳 = 0，值 = 5
  • 元素 2：时间戳 = 4，值 = 6
  • 元素 3：时间戳 = 6，值 = 10
  • 元素 4：时间戳 = 12，值 = 1

我想在输出中有这个列表：

  • 元素 1：时间戳 = 0，值 = 5
  • 元素 2：时间戳 = 1，值 = 0
  • 元素 3：时间戳 = 3，值 = 0
  • 元素 4：时间戳 = 4，值 = 6
  • 元素 5：时间戳 = 5，值 = 0
  • 元素 6：时间戳 = 6，值 = 10
  • 元素 7：时间戳 = 7，值 = 0
  • 元素 8：时间戳 = 11，值 = 0
  • 元素 9：时间戳 = 12，值 = 1

我将尝试简短地解释我需要什么。当两个时间戳不是连续的整数时，我需要在它们之间放置最小数量的零。例如，在上面列表中的时间戳 4 和 6 之间的情况下，我只需要放置一个零，但在两个时间戳相差两个或更多的情况下，我需要在第一个时间戳之后放置一个零，然后放置一个零紧接在第二个时间戳之前。您可以在时间戳 6 和 10 之间看到这一点。我还需要放置的零具有正确的时间戳集。

现在我不知道如何解决它。谢谢您的支持！

这是使用您的建议对我有用的解决方案：

public static List<TimestampAndValue> insertMinimumNumberOfZerosBetweenValues(List<TimestampAndValue> list){
    if(list == null || list.isEmpty() || list.size() == 1)
        return list;

    int i;
    int j;
    long tempTimestamp1;
    long tempTimestamp2;
    long timestampDifference;

    List<TimestampAndValue> outList = new ArrayList<TimestampAndValue>();

    outList.add(list.get(0));
    for(i=0; i<list.size()-1; i++){
        j=i+1;

        tempTimestamp1 = list.get(i).getTimestamp();
        tempTimestamp2 = list.get(j).getTimestamp();
        timestampDifference = tempTimestamp2 - tempTimestamp1;

        if(timestampDifference == 2){
            TimestampAndValue tav = new TimestampAndValue();
            tav.setTimestamp(tempTimestamp1 + 1);
            tav.setValue(0);

            outList.add(tav);
        }
        else if(timestampDifference > 2){
            TimestampAndValue tav = new TimestampAndValue();
            tav.setTimestamp(tempTimestamp1 + 1);
            tav.setValue(0);

            outList.add(tav);

            TimestampAndValue tav2 = new TimestampAndValue();
            tav2.setTimestamp(tempTimestamp2 - 1);
            tav2.setValue(0);

            outList.add(tav2);
        }                

        outList.add(list.get(j));
    }

    return outList;
}
4

4 回答 4

0

这是作业吗？如果是这样，请标记为这样。

也许我误解了这个问题，但我认为一个简单的循环应该可以工作。按时间戳对列表进行排序，然后遍历所有值。一旦找到不连续的时间戳，就插入一个 0 条目。

于 2012-04-19T16:14:10.740 回答
0

您必须处理输入列表中的时间戳对，累积输出列表：

outputList = new list of timestamps;

for (int i = 0; i < numerOfTimestamps-1; i++) {
    timestamp1 = inputList.get(i);
    timestamp2 = inputList.get(i+1);

对于每一对，比较它们之间的距离：

  • 如果它们是连续的，则添加timestamp1到输出列表
  • 如果差值小于 2，则在输出列表中添加timestamp1一个新的时间戳0
  • 如果差值等于或大于二，则添加timestamp1两个新的时间戳0到输出列表

然后

} // close loop

并将最后一个时间戳添加到输出列表中。（它永远不会被循环添加。）

请注意，您需要单独处理空输入列表。

于 2012-04-19T16:15:04.877 回答
0

也许我没有正确解决您的问题，但是您是否尝试过实现一种机制，如果时间戳不存在，则返回默认值 0？它将更加高效和简单

于 2012-04-19T16:06:43.730 回答
0

首先一个问题为什么你需要介于两者之间的那些整数？

下一个建议（未测试）：

List<TimestampAndValue> newList = new ArrayList<TimestampAndValue>();
TimestampAndValue lastAdded = null;    

for( int i = 0; i < oldList.length; i++ ) {   
  if( i > 0 && !isContiguous(lastAdded, oldList[i])) {
    newList.add(new TimestampAndValue(oldList[i].timestamp - 1, 0.0 ) );
  }

  newList.add( oldList[i] );
  lastAdded = oldList[i];

  if( i < (oldList.length - 1) && !isContiguous(oldList[i], oldList[i+1]) {
    lastAdded = new TimestampAndValue(oldList[i].timestamp + 1, 0.0 );
    newList.add( lastAdded );
  }
}

基本上，您遍历列表并将元素插入到新列表中。如果新列表中的最后一个值不连续，则首先添加一个 0 条目。如果下一个条目不连续，则在之后添加一个 0 条目。

请注意，您仍然需要isContiguous( ... )正确实现和处理 null。

于 2012-04-19T16:16:55.077 回答