当前位置：首页 > article >正文

《苍穹外卖》项目学习记录-Day11订单统计

article 2025/2/3 15:00:28

根据起始时间和结束时间，先把begin放入集合中用while循环当begin不等于end的时候，让begin加一天，这样就把这个区间内的时间放到List集合。

查询每天的订单总数也就是查询的时间段是大于当天的开始时间（0点0分0秒）小于当天的结束时间的（23点59分59秒）的。

//查询每天的订单总数 select count(id) from orders where order_time > ? and order_time < ?

查询有效订单数，不仅是当天的时间段还要状态是已完成的订单，status=5代表已完成。

//查询每天的有效订单数 select count(id) from orders where order_time > ? and order_time < ? and status = 5

/**
     * 统计指定时间区间内的订单数据
     * @param begin
     * @param end
     * @return
     */
    public OrderReportVO getOrderStatistics(LocalDate begin, LocalDate end) {
        //存放从begin到end之间的每天对应的日期
        List<LocalDate> dateList = new ArrayList<>();
        dateList.add(begin);
        while (!begin.equals(end)){
            begin = begin.plusDays(1);
            dateList.add(begin);
        }
        //存放每天的订单总数
        List<Integer> orderCountList = new ArrayList<>();
        //存放每天的有效订单数
        List<Integer> validOrderCountList = new ArrayList<>();
        //遍历dateList集合，查询每天的有效订单数和订单总数
        for (LocalDate date : dateList) {
            //查询每天的订单总数 select count(id) from orders where order_time > ? and order_time < ?
            LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
            LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
            Integer orderCount = getOrderCount(beginTime, endTime,null);
            //查询每天的有效订单数 select count(id) from orders where order_time > ? and order_time < ? and status = 5
            Integer validOrderCount = getOrderCount(beginTime, endTime, Orders.COMPLETED);
            orderCountList.add(orderCount);
            validOrderCountList.add(validOrderCount);
        }
        //计算时间区间内的订单总数量
        Integer totalOrderCount = orderCountList.stream().reduce(Integer::sum).get();
        //计算时间区间内的有效订单数量
        Integer validOrderCount = validOrderCountList.stream().reduce(Integer::sum).get();

        Double orderCompletionRate = 0.0;
        if (totalOrderCount != 0){
            //计算订单完成率
            orderCompletionRate = validOrderCount.doubleValue() / totalOrderCount;
        }
        return OrderReportVO.builder()
                .dateList(StringUtils.join(dateList,","))
                .orderCountList(StringUtils.join(orderCountList,","))
                .validOrderCountList(StringUtils.join(validOrderCountList,","))
                .totalOrderCount(totalOrderCount)
                .validOrderCount(validOrderCount)
                .orderCompletionRate(orderCompletionRate)
                .build();
    }
    private Integer getOrderCount(LocalDateTime begin,LocalDateTime end,Integer status){
        Map map = new HashMap();
        map.put("begin",begin);
        map.put("end",end);
        map.put("status",status);
        return orderMapper.countByMap(map);
    }

Stream流的使用步骤

1.获取Stream流？

·获取集合的Stream流

Collection提供的如下方法说明

default Stream<E> stream() 获取当前集合对象的Stream流

·获取数组的Stream流

Arrays类提供的如下方法说明

public static <T> Stream<T> stream(T[] array) 获取当前数组的Stream流

public static <T> Stream<T> of(T...values) 获取当前接收数据的Stream流

中间方法指的是调用完成后会返回新的Stream流，可以继续使用（支持链式编程）。

终结方法指的是调用完成后，不会返回新的Stream了，没法继续使用流了。

2.Stream提供的常用中间方法说明

Stream <T> filter(Predicate<? super T>predicate) 用于对流中的数据进行过滤

Stream <T> sorted() 对元素进行升序排序

Stream <T> sorted(Comparator<? super T> comparator) 按照指定规则排序

Stream <T> limit(long maxSize) 获取前几个元素

Stream <T> skip(long n) 跳过前几个元素

Stream <T> distinct() 去除流中重复的元素

<R>Stream<R> map(Function<? super T,?extends R> mapper)

对元素进行加工，并返回对应的新流

static <T> Stream<T> concat(Stream a,Stream b) 合并a和b两个流为一个流

3.Stream流常见的终结方法

Stream提供的常用终结方法说明

void forEach(Consumer action) 对此流运算后的元素执行遍历

long count() 统计此流运算后的元素个数

Optional<T> max(Comparator<? super T> comparator)

获取此流运算后最大值元素

Optional<T> min(Comparator<? super T> comparator)

获取此流运算后最小值元素

收集Stream流：就是把Stream流操作后的结果转回到集合或者数组中去返回。

Stream流：方便操作集合/数组手段；集合/数组：才是开发中的目的。

Stream提供的常用终结方法说明

R collect(Collector collector) 把流处理后的结果收集到一个指定的集合中去

Object toArray() 把流处理后的结果收集到一个数组中去

流只能收集一次

Collectors工具类提供了具体的收集方式说明

public static <T> Collector toList() 把元素收集到List集合中去

public static <T> Collector toSet() 把元素收集到Set集合中去

public static Collector toMap(Function KeyMapper,Function valueMapper)

把元素收集到Map集合中

我的笔记中没有这个Stream.reduce()方法，所以我去查了一下。

Stream.reduce()是Java 8引入的一个强大的工具，用于对流中的元素进行归纳操作。

reduce方法可以将流中的多个元素组合成一个单一的结果，通常用于求和、求乘积、查找最大值或最小值等操作。

reduce方法的基本用法

reduce(BinaryOperator<T> accumulator)

这种方法没有初始值，流的第一个元素将作为初始值。返回的是Optional<T>，以防流为空。例如：

Optional<Integer> sum = list.stream().reduce((a,b)->a + b);

2.有初始值‌：T reduce(T identity, BinaryOperator<T> accumulator)。这种方法有一个初始值identity，可以保证即使流为空也会有一个默认结果。返回的是T。例如：
int sum = list.stream().reduce(0, (a, b) -> a + b);
‌3.并行流操作‌：reduce(U identity, BiFunction<U, T, U> accumulator, BinaryOperator<U> combiner)。这种方法适用于并行流操作，可以通过两个函数实现累加器和合并器的分离。例如：
int sum = list.parallelStream().reduce(0, (partialResult, element) -> partialResult + element, Integer::sum);
reduce方法的应用场景
‌1.求和‌：将流中的所有元素相加。例如，计算一个整数列表的总和。
‌2.求乘积‌：将流中的所有元素相乘。例如，计算一个整数列表的乘积。
‌3.查找最大值或最小值‌：通过比较操作，找到流中的最大值或最小值。
‌4.连接字符串‌：将流中的字符串元素连接成一个新的字符串。例如，将多个单词连接成一个句子。
‌5.自定义聚合操作‌：通过自定义的累加器函数，实现更复杂的聚合操作。例如，计算两个数的平均值。

查看全文

http://www.kler.cn/a/529892.html