按时间分组对象

首先，您的预期值有问题。对象 2.2 有一个时间戳 "19/09/2020 1:04:00 AM"，它应该 "19/09/2020 1:04:30 AM"，对吧？对象 3.2 也是如此。顺便说一句，最后一个组号应该是 3，而不是 2，对吧？

对象 2.2 的平均值尚不清楚。你1.5，可是应该的(1.9+2.1)/2 -> 2.0。

现在做决定。

如果您以一种简单的方式直接决定，而不进行内存优化，那么我会这样做。

将期间拆分为不重叠的窗口。例如，在您的情况下，60 秒的时间段分为两个窗口。进一步在一个无限循环中——如果对象属于当前区间，则将其添加到相应的窗口中，否则，关闭区间并开始下一个，直到对象在区间内。

关闭窗口意味着Item使用与窗口开始相对应的时间戳和等于窗口时间平均值的值。

窗口代码。

package org.example.groups;


import java.text.ParseException;

public class Window {
    public static final long PERIOD = 60000;
    
    public final int windowId;
    public long start;
    public long end;
    public int count = 0;
    public double sum = 0.0;
    public double lastValue = 0.0;
    
    public Window(long start, long duration, int windowId) {
        this.windowId = windowId;
        this.start = start;
        this.end = start + duration;
    }
    
    public double add(double v) throws ParseException {
        count +=1;
        sum += v;
        return value();
    }
    
    public double value() {
        if (count == 0) {
            return lastValue;
        }
        return sum / count;
    }
    
    public Item shift()  {
        return shift(1);
    }
    
    public Item shift(int n) {
        Item result = toItem();
        
        lastValue = value();        
        sum = 0.0;
        count = 0;
        start += n*PERIOD;
        end += n*PERIOD;
        
        return result;
    }
    
    public Item toItem() {
        return new Item(
                windowId,
                Util.toDateString(start),
                value()
                );
    }
    
    public boolean isIn(long t) throws ParseException {
        return (start <= t && t < end); 
    }
}

计算平均值的代码：

package org.example.groups;

import java.text.ParseException;
import java.util.LinkedList;
import java.util.List;

public class Average {
    public List<Item> items;

    private Window[] windows;
    private double lastValue = 0.0;

    private final long duration;

    public Average(long start, int numOfWindows) {
        items = new LinkedList<Item>();
        long intervalStart = Util.periodStart(start);
        long intervalEnd = intervalStart + Window.PERIOD;
        
        duration = Window.PERIOD / numOfWindows;
        windows = new Window[numOfWindows];
        
        for (int i = 0; i < numOfWindows; i++) {
            windows[i] = new Window(intervalStart + duration*i, duration, i+1);
        }
        windows[numOfWindows-1].end = intervalEnd;
    }
    
    private long intervalStart() {
        return windows[0].start;
    }
    
    private long intervalEnd() {
        return intervalStart() + Window.PERIOD;
    }

    private boolean isIn(long t) {
        return (intervalStart() <= t && t < intervalEnd());
    }

    private void finishPeriod() {
        for (Window w : windows) {
            w.lastValue = lastValue;
            Item it = w.shift();
            lastValue = it.getValue();
            items.add(it);
        }
    }

    public void add(Item it) throws ParseException {
        long t = Util.timeInMillis(it);
        while (!isIn(t)) {
            finishPeriod();
        }
        int wIdx = (int) ((t - intervalStart()) / duration);
        assert(wIdx < windows.length);
        windows[wIdx].add(it.getValue());
    }
    
    public List<Item> finish() {
        finishPeriod();
        return items;
    }
    
    public List<Group> groupify() {
        LinkedList<Group> result = new LinkedList<Group>();
        
        int itemsPerGroup = windows.length;
        int groupId = 1;
        for (int i = 0; i < items.size(); i+=itemsPerGroup) {
            Group g = new Group(groupId++, items.subList(i, i+itemsPerGroup));
            result.add(g);
        }
        return result;
    }
}

该类Average由间隔的开始和时段内的窗口数参数化。Window.PERIOD周期的持续时间由以毫秒为单位的常数给出。如果需要，该方法public void add(Item it)会移动间距，然后将对象添加到适当的窗口。当间隔移动时，平均值被添加到列表中items。

为简单起见，我将对象作为一个整体写在一个列表中，并且仅在必要时将它们分组收集，但可以在finishPeriod.

这个解决方案有什么问题。

1. 可以通过在间隔内滑动的单个窗口来解决问题。

2. 在数据中的时间戳之间存在较大差距的情况下，可以不保存 "empty" Item，而只保存有数据的那些间隔。

完整代码：https ://github.com/pakuula/StackOverflow/tree/main/java/1450111

一个周期内运行两个区间的示例：

package org.example.groups;

import java.text.ParseException;
import java.util.List;

public class Main {
    public static void main(String[] args) throws ParseException {
        List<Item> items = List.of(
                new Item(1, "19/09/2020 1:03:00 AM", 1.0),
                new Item(2, "19/09/2020 1:03:03 AM", 1.3),
                new Item(3, "19/09/2020 1:03:15 AM", 1.1),
                new Item(4, "19/09/2020 1:03:47 AM", 1.2),
                new Item(5, "19/09/2020 1:03:57 AM", 1.6),
                new Item(6, "19/09/2020 1:04:04 AM", 1.8),
                new Item(7, "19/09/2020 1:04:43 AM", 1.9),
                new Item(8, "19/09/2020 1:04:44 AM", 2.1),
                new Item(9, "19/09/2020 1:05:30 AM", 1.8),
                new Item(10, "19/09/2020 1:05:46 AM", 2.3)
        );
        long start = Util.timeInMillis(items.get(0));
        start = Util.periodStart(start);
        
        Average av = new Average(start, 2);

        for (Item it : items) {
            av.add(it);
        }
        av.finish()
    
        for (Group g : av.groupify()) {
            System.out.println(g.toString());
        }
    }
}

结论：

Group [id=1, items=[Item [id=1, time=Sat Sep 19 01:03:00 KST 2020, value=1.13], Item [id=2, time=Sat Sep 19 01:03:30 KST 2020, value=1.40]]]
Group [id=2, items=[Item [id=1, time=Sat Sep 19 01:04:00 KST 2020, value=1.80], Item [id=2, time=Sat Sep 19 01:04:30 KST 2020, value=2.00]]]
Group [id=3, items=[Item [id=1, time=Sat Sep 19 01:05:00 KST 2020, value=2.00], Item [id=2, time=Sat Sep 19 01:05:30 KST 2020, value=2.05]]]