场景

在统计时间范围的数据时，数据库中有可能缺少一部分数据，比如：

  1. 按小时统计：数据库中只有 2021-08-01 03 、2021-08-01 08 点的汇总数据

首先这两个时间点中缺少以下小时数据，但是展示曲线图的时候，需要填充好这些数据，使用 0 填充

  1. 2021-08-01 04、2021-08-01 05、2021-08-01 06、2021-08-01 07
  1. 按天统计：数据库中只有 2021-08-01、2021-08-03 的数据，中间缺少了 2021-08-02 的数据，同样需要用 0 填充

以上两个举例，在时间跨度很大的时候，就比较麻烦了，所以有了该工具类

方案

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Map;
  4. import java.util.function.Function;
  5. import java.util.function.Supplier;
  6. import java.util.stream.Collectors;
  8. import cn.hutool.core.date.DateTime;
  9. import cn.hutool.core.date.DateUnit;
  10. import cn.hutool.core.date.DateUtil;
  11. import cn.hutool.core.util.ArrayUtil;
  12. import lombok.extern.slf4j.Slf4j;
  14. /**
  15.  * @author mrcode
  16.  * @date 2021/8/30
  17.  */
  18. public class StatisticsOverviewService {
  19.     /**
  20.      * 填充缺少的 小时 数据，缺少的值一般用 0 填充； 注意：会从第一条数据的 00 小时开始填充，直到最后一条数据  23 点
  21.      *
  22.      * @param res 至少需要两条数据
  23.      * @param defaultObjectFactory 默认值对象工厂，当需要填充时，请返回一个用 0 填充的对象
  24.      * @param <T>
  25.      * @return
  26.      */
  27.     public static <T extends StatisticsOverviewDataItem> List<T> fillDataOfHour(List<T> res,
  28.                                                                                 Supplier<T> defaultObjectFactory) {
  29.         final T first = res.get(0);
  30.         final T end = res.get(res.size() - 1);
  32.         final int firstTime = first.getTime();
  33.         DateTime firstTimeDate = DateUtil.parse(firstTime + "", "yyyyMMddHH");
  34.         firstTimeDate = DateUtil.beginOfDay(firstTimeDate); // 一天的开始
  35.         final int endTime = end.getTime();
  36.         DateTime endTimeDate = DateUtil.parse(endTime + "", "yyyyMMddHH");
  37.         endTimeDate = DateUtil.endOfDay(endTimeDate); // 一天的结束
  39.         final Map<Integer, T> dataMppings = res.parallelStream().collect(Collectors.toMap(T::getTime, Function.identity()));
  40.         final long betweenHour = DateUtil.between(firstTimeDate, endTimeDate, DateUnit.HOUR);
  41.         List<T> result = new ArrayList<>((int) betweenHour + 1);
  43.         DateTime tempStartTime = firstTimeDate;
  44.         String currentDayStr = ""; // 20210201
  45.         int currentDayOfHour = 0; // 当前处理的小时
  46.         while (tempStartTime.isBefore(endTimeDate)) {
  47.             currentDayStr = DateUtil.format(tempStartTime, "yyyyMMdd");
  48.             for (int i = 0; i < 24; i++) {
  49.                 currentDayOfHour = Integer.parseInt(currentDayStr + (i < 10 ? "0" + i : i));
  50.                 final T item = dataMppings.get(currentDayOfHour);
  51.                 if (item == null) {
  52.                     final T newItem = defaultObjectFactory.get();
  53.                     newItem.setTime(currentDayOfHour);
  54.                     result.add(newItem);
  55.                 } else {
  56.                     result.add(item);
  57.                 }
  58.             }
  59.             tempStartTime = DateUtil.offsetDay(tempStartTime, 1);
  60.         }
  61.         return result;
  62.     }
  64.     /**
  65.      * 填充缺少的 天 数据，缺少的值一般用 0 填充;
  66.      *
  67.      * @param res 至少需要两条数据
  68.      * @param defaultObjectFactory 默认值对象工厂，当需要填充时，请返回一个用 0 填充的对象
  69.      * @param <T>
  70.      * @return
  71.      */
  72.     public static <T extends StatisticsOverviewDataItem> List<T> fillDataOfDay(List<T> res,
  73.                                                                                Supplier<T> defaultObjectFactory) {
  74.         final T first = res.get(0);
  75.         final T end = res.get(res.size() - 1);
  76.         final int firstTime = first.getTime();
  77.         final DateTime firstTimeDate = DateUtil.beginOfDay(DateUtil.parse(firstTime + "", "yyyyMMdd"));
  78.         final int endTime = end.getTime();
  79.         final DateTime endTimeDate = DateUtil.beginOfDay(DateUtil.parse(endTime + "", "yyyyMMdd"));
  81.         // 计算中间相差多少天，如 20210102 和 20210104，相差大于 1，则表示有不连续的日期，有可能需要填充 20210103 日期的数据
  82.         final long betweenDay = DateUtil.betweenDay(firstTimeDate, endTimeDate, false);
  83.         if (betweenDay == 1) {
  84.             return res;
  85.         }
  86.         // 处理中间有可能缺失是数据
  87.         DateTime tempStartTime = firstTimeDate;
  88.         final Map<Integer, T> dataMppings = res.parallelStream().collect(Collectors.toMap(T::getTime, Function.identity()));
  89.         List<T> result = new ArrayList<>((int) betweenDay + 1);
  90.         int currentDay = 0;
  91.         while (tempStartTime.isBeforeOrEquals(endTimeDate)) {
  92.             currentDay = Integer.parseInt(DateUtil.format(tempStartTime, "yyyyMMdd"));
  93.             final T item = dataMppings.get(currentDay);
  94.             if (item == null) {
  95.                 final T newItem = defaultObjectFactory.get();
  96.                 newItem.setTime(currentDay);
  97.                 result.add(newItem);
  98.             } else {
  99.                 result.add(item);
  100.             }
  101.             tempStartTime = DateUtil.offsetDay(tempStartTime, 1);
  102.         }
  103.         return result;
  104.     }
  107.     /**
  108.      * 将字符串时间范围转换为 int 时间范围
  109.      *
  110.      * @param timeRange，比如 2021、2021-02、2021-02-01
  111.      * @return
  112.      */
  113.     public static Integer[] timeRangeToTimeRangeInt(String[] timeRange) {
  114.         Integer[] result = new Integer[2];
  115.         if (ArrayUtil.isEmpty(timeRange)) {
  116.             return result;
  117.         }
  118.         final String startItem = timeRange[0];
  119.         final String endItem = timeRange[1];
  120.         if (startItem != null) {
  121.             result[0] = Integer.parseInt(startItem.replace("-", ""));
  122.         }
  123.         if (endItem != null) {
  124.             result[1] = Integer.parseInt(endItem.replace("-", ""));
  125.         }
  126.         return result;
  127.     }
  128. }
  1. public interface StatisticsOverviewDataItem {
  2.     int getTime();
  4.     void setTime(int time);
  5. }

测试类

  1. import org.junit.jupiter.api.Test;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * @author mrcode
  8.  * @date 2021/8/30
  9.  */
  10. class StatisticsOverviewServiceTest {
  12.     @Test
  13.     void fillDataOfHour() {
  14.         final ArrayList<DataItem> res = new ArrayList<>();
  15.         res.add(new DataItem(2021082020, 36));
  16.         res.add(new DataItem(2021082105, 20));
  17.         final List<DataItem> dataItems = StatisticsOverviewService.fillDataOfHour(res, DataItem::defaultObject);
  18.         for (DataItem dataItem : dataItems) {
  19.             System.out.println(dataItem);
  20.         }
  21.     }
  23.     @Test
  24.     void fillDataOfDay() {
  25.         final ArrayList<DataItem> res = new ArrayList<>();
  26.         res.add(new DataItem(20201230, 36));
  27.         res.add(new DataItem(20210106, 20));
  28.         final List<DataItem> dataItems = StatisticsOverviewService.fillDataOfDay(res, DataItem::defaultObject);
  29.         for (DataItem dataItem : dataItems) {
  30.             System.out.println(dataItem);
  31.         }
  32.     }
  35.     static class DataItem implements StatisticsOverviewDataItem {
  36.         private int count; // 数量
  37.         private int time; // 时间
  39.         public DataItem() {
  40.         }
  42.         public DataItem(int time, int count) {
  43.             this.count = count;
  44.             this.time = time;
  45.         }
  47.         public static DataItem defaultObject() {
  48.             final DataItem item = new DataItem();
  49.             item.setCount(0);
  50.             return item;
  51.         }
  53.         @Override
  54.         public int getTime() {
  55.             return time;
  56.         }
  58.         @Override
  59.         public void setTime(int time) {
  60.             this.time = time;
  61.         }
  63.         public int getCount() {
  64.             return count;
  65.         }
  67.         public void setCount(int count) {
  68.             this.count = count;
  69.         }
  71.         @Override
  72.         public String toString() {
  73.             return "DataItem{" +
  74.                     "time=" + time +
  75.                     ", count=" + count +
  76.                     '}';
  77.         }
  78.     }
  79. }

测试信息如下：
fillDataOfHour 测试

  1. DataItem{time=2021082000, count=0}
  2. DataItem{time=2021082001, count=0}
  3. DataItem{time=2021082002, count=0}
  4. DataItem{time=2021082003, count=0}
  5. DataItem{time=2021082004, count=0}
  6. DataItem{time=2021082005, count=0}
  7. DataItem{time=2021082006, count=0}
  8. DataItem{time=2021082007, count=0}
  9. DataItem{time=2021082008, count=0}
  10. DataItem{time=2021082009, count=0}
  11. DataItem{time=2021082010, count=0}
  12. DataItem{time=2021082011, count=0}
  13. DataItem{time=2021082012, count=0}
  14. DataItem{time=2021082013, count=0}
  15. DataItem{time=2021082014, count=0}
  16. DataItem{time=2021082015, count=0}
  17. DataItem{time=2021082016, count=0}
  18. DataItem{time=2021082017, count=0}
  19. DataItem{time=2021082018, count=0}
  20. DataItem{time=2021082019, count=0}
  21. DataItem{time=2021082020, count=36}
  22. DataItem{time=2021082021, count=0}
  23. DataItem{time=2021082022, count=0}
  24. DataItem{time=2021082023, count=0}
  25. DataItem{time=2021082100, count=0}
  26. DataItem{time=2021082101, count=0}
  27. DataItem{time=2021082102, count=0}
  28. DataItem{time=2021082103, count=0}
  29. DataItem{time=2021082104, count=0}
  30. DataItem{time=2021082105, count=20}
  31. DataItem{time=2021082106, count=0}
  32. DataItem{time=2021082107, count=0}
  33. DataItem{time=2021082108, count=0}
  34. DataItem{time=2021082109, count=0}
  35. DataItem{time=2021082110, count=0}
  36. DataItem{time=2021082111, count=0}
  37. DataItem{time=2021082112, count=0}
  38. DataItem{time=2021082113, count=0}
  39. DataItem{time=2021082114, count=0}
  40. DataItem{time=2021082115, count=0}
  41. DataItem{time=2021082116, count=0}
  42. DataItem{time=2021082117, count=0}
  43. DataItem{time=2021082118, count=0}
  44. DataItem{time=2021082119, count=0}
  45. DataItem{time=2021082120, count=0}
  46. DataItem{time=2021082121, count=0}
  47. DataItem{time=2021082122, count=0}
  48. DataItem{time=2021082123, count=0}

fillDataOfDay 测试

  1. # 跨年填充也是正常的
  2. DataItem{time=20201230, count=36}
  3. DataItem{time=20201231, count=0}
  4. DataItem{time=20210101, count=0}
  5. DataItem{time=20210102, count=0}
  6. DataItem{time=20210103, count=0}
  7. DataItem{time=20210104, count=0}
  8. DataItem{time=20210105, count=0}
  9. DataItem{time=20210106, count=20}