java 利用echart统计折线图，柱状图

已于 2022-08-26 15:01:46 修改
阅读量2.2k 收藏 8
点赞数 5
文章标签： java
于 2022-08-20 15:14:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljs62811123/article/details/126439889
版权

java 利用echart统计折线图，柱状图

后端返回数据结构

文章目录

前言

统计大数据

在这里插入图片统计图描述

二、使用步骤

1.时间统计工具

需要引入hutool 的依赖

  <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.4</version>
        </dependency>

工具类

package com.ruoyi.common.utils;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
 * 运营中心统计一些时间的返回
 *
 * @author :ljs
 * @date : 2022/8/17
 */
public class OperatCenterTimeUtil {
    /**
     * 获取时间
     *
     * @return
     */
    public static List<String> getHours() {
        List<String> list = new ArrayList<>();
        String hours[] = {"00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14",
                "15",
                "16",
                "17",
                "18",
                "19",
                "20",
                "21",
                "22",
                "23"
        };
        list = Arrays.asList(hours);
        return list;
    }

    /**
     * 获取本月的全部日期
     */
    public static List<String> getMonthDay() {
        List<String> monthDayList = new ArrayList<>();
        //本月最后一天
        DateTime dateTime = DateUtil.endOfMonth(new Date());
        String endDateTimeStr = DateUtil.format(dateTime, "YYYY-MM-dd");
        //获取最后一个字符就是天
        String day = endDateTimeStr.substring(endDateTimeStr.lastIndexOf("-") + 1);
        //天前面的
        for (int i = 1; i <= Integer.valueOf(day); i++) {
            String startStr = endDateTimeStr.substring(0, endDateTimeStr.lastIndexOf("-") + 1);
            if (i < 10) {
                startStr += "0" + i;
            } else {
                startStr += i;
            }


            monthDayList.add(startStr);
        }
        return monthDayList;
    }

    /**
     * 获取本周天数
     */
    public static List<String> getWeekDay() {
        List<String> weekDayList = new ArrayList<>();
        //本月最后一天
        String weeks[] = {"周一", "周二", "周三", "周四", "周五", "周六", "周日"};
        List<String> weekList = Arrays.asList(weeks);
        DateTime beginWeekDay = DateUtil.beginOfWeek(new Date());
        String beginWeekDayStr = DateUtil.format(beginWeekDay, "YYYY-MM-dd");
        //获取最后一个字符就是天
        String beginDay = beginWeekDayStr.substring(beginWeekDayStr.lastIndexOf("-") + 1);
        //查询本周的最后一天
        DateTime lastWeekDay = DateUtil.endOfWeek(new Date());
        String lastWeekDayStr = DateUtil.format(lastWeekDay, "YYYY-MM-dd");
        //获取最后一个字符就是天
        String endDay = lastWeekDayStr.substring(lastWeekDayStr.lastIndexOf("-") + 1);
        //天前面的
        for (int i = Integer.valueOf(beginDay); i <= Integer.valueOf(endDay); i++) {
            String startStr = beginWeekDayStr.substring(0, beginWeekDayStr.lastIndexOf("-") + 1);
            startStr += i;
            weekDayList.add(startStr);
        }
        //加后缀
      /*  List<String> finalList = new ArrayList<>();
        for (int i = 0; i < weekDayList.size(); i++) {
            String day = weekDayList.get(i) + "(" + weekList.get(i) + ")";
            finalList.add(day);
        }*/
        return weekDayList;
    }

    /**
     * 获取本年的所有月份
     *
     * @param
     */
    public static List<String> getYearMonth() {
        List<String> yearMonthList = new ArrayList<>();
        //查询本周的最后一天
        DateTime lastYearMonth = DateUtil.endOfYear(new Date());
        String lastYearMonthStr = DateUtil.format(lastYearMonth, "YYYY-MM");
        //天前面的
        for (int i = 1; i <= 12; i++) {
            String startStr = lastYearMonthStr.substring(0, lastYearMonthStr.lastIndexOf("-") + 1);
            if (i < 10) {
                startStr += "0" + i;
            } else {
                startStr += i;
            }

            yearMonthList.add(startStr);
        }
        return yearMonthList;
    }

    /**
     * 获取去年的所有月份
     *
     * @param
     */
    public static List<String> getLastYearMonth() {
        List<String> yearMonthList = new ArrayList<>();
        //查询本周的最后一天
        DateTime lastYearMonth = DateUtil.endOfYear(new Date());
        String lastYearMonthStr = DateUtil.format(lastYearMonth, "YYYY-MM");
        String year = lastYearMonthStr.substring(0, lastYearMonthStr.lastIndexOf("-"));
        //获取年
        //天前面的
        for (int i = 1; i <= 12; i++) {
            int lastYear = Integer.valueOf(year) - 1;
            String startStr = String.valueOf(lastYear);
            if (i < 10) {
                startStr += "-" + "0" + i;
            } else {
                startStr += "-" + i;
            }

            yearMonthList.add(startStr);
        }
        return yearMonthList;
    }
}



## 2.sql 查询年月日的统计，时间是时间戳，根据时间来分组
%H是24小时，%h是12小时

```sql
    select  sum(
 IF( pay_status = 1, product_count, 0 )) as productCount,
            count(id) as count,
          sum(
 IF
 ( pay_status = 1, pay_money, 0 )) as payMoney,
             ROUND (avg(IF
 ( pay_status = 1, pay_money, 0 )),2) as avgMoney,FROM_UNIXTIME(created_at,'%H') as time  from  dz_addon_shop_order where     to_days(FROM_UNIXTIME(created_at,'%Y-%m-%d')) = TO_DAYS(now()) group by time
						-- 统计
		
-- 昨天
     select  sum(
 IF( pay_status = 1, product_count, 0 )) as productCount,
            count(id) as count,
          sum(
 IF
 ( pay_status = 1, pay_money, 0 )) as payMoney,
             ROUND (avg(IF
 ( pay_status = 1, pay_money, 0 )),2) as avgMoney,FROM_UNIXTIME(created_at,'%H') as time from  dz_addon_shop_order where DATEDIFF(now(),FROM_UNIXTIME(created_at,'%Y-%m-%d'))=1  group by time
		
			 
-- 本周
  select  sum(
 IF( pay_status = 1, product_count, 0 )) as productCount,
            count(id) as count,
          sum(
 IF
 ( pay_status = 1, pay_money, 0 )) as payMoney,
             ROUND (avg(IF
 ( pay_status = 1, pay_money, 0 )),2) as avgMoney,FROM_UNIXTIME(created_at,'%Y-%m-%d') as time from  dz_addon_shop_order where  YEARWEEK(date_format(FROM_UNIXTIME(created_at,'%Y-%m-%d'),'%Y-%m-%d'),1) = YEARWEEK(now(),1)  group by time
-- 本月
	  select  sum(
 IF( pay_status = 1, product_count, 0 )) as productCount,
            count(id) as count,
          sum(
 IF
 ( pay_status = 1, pay_money, 0 )) as payMoney,
             ROUND (avg(IF
 ( pay_status = 1, pay_money, 0 )),2) as avgMoney,FROM_UNIXTIME(created_at,'%Y-%m-%d') as time from  dz_addon_shop_order where 	date_format(from_unixtime(created_at),'%Y-%m') = date_format(now(), '%Y-%m') group by time

	-- 本年
  select  sum(
 IF( pay_status = 1, product_count, 0 )) as productCount,
            count(id) as count,
          sum(
 IF
 ( pay_status = 1, pay_money, 0 )) as payMoney,
             ROUND (avg(IF
 ( pay_status = 1, pay_money, 0 )),2) as avgMoney,FROM_UNIXTIME(created_at,'%Y-%m') as time from  dz_addon_shop_order where YEAR(FROM_UNIXTIME(created_at,'%Y-%m-%d')) = YEAR(NOW()) group by time
-- 去年
	  select  sum(
 IF( pay_status = 1, product_count, 0 )) as productCount,
            count(id) as count,
          sum(
 IF
 ( pay_status = 1, pay_money, 0 )) as payMoney,
             ROUND (avg(IF
 ( pay_status = 1, pay_money, 0 )),2) as avgMoney,FROM_UNIXTIME(created_at,'%Y-%m') as time from  dz_addon_shop_order where 	  YEAR(FROM_UNIXTIME(created_at,'%Y-%m-%d')) = YEAR(DATE_SUB(NOW(),INTERVAL 1 YEAR)) group by time
		
-- 时间段
		   select  sum(
 IF( pay_status = 1, product_count, 0 )) as productCount,
            count(id) as count,
          sum(
 IF
 ( pay_status = 1, pay_money, 0 )) as payMoney,
             ROUND (avg(IF
 ( pay_status = 1, pay_money, 0 )),2) as avgMoney,FROM_UNIXTIME(created_at,'%Y-%m-%d') as time from  dz_addon_shop_order where FROM_UNIXTIME(created_at,'%Y-%m-%d')  between '2022-08-15' and  '2022-08-17'	 group by time

后台接口数据整合

/**
 * 订单统计返回折现图结构
 *
 * @author :ljs
 * @date : 2022/8/17
 */
@Data
public class OrderFieldResponse implements Serializable {
    @ApiModelProperty("图形的种类")
    private List<String> fieldsName;
    @ApiModelProperty("图形的种类的数值")
    private List<SeriesDataResponse> seriesData;
    @ApiModelProperty("图形的种类的数值")
    private List<String> xAxisData;
}

对应的mapper

``    /**
     * 获取今天的订单总数
     */
    List<OrderSumResponse> getToday();

    /**
     * 获取昨天的订单总数
     */
    List<OrderSumResponse> getYesterday();

    /**
     * 获取本周的订单总数
     */
    List<OrderSumResponse> getWeek();

    /**
     * 获取本月的订单总数
     */
    List<OrderSumResponse> getMonth();

    /**
     * 获取本年的订单总数
     */
    List<OrderSumResponse> getYear();

    /**
     * 获取去年的订单总数
     *
     * @return
     */
    List<OrderSumResponse> getLastYear();

返回数据结构

public OrderFieldResponse getOrderSum(TypeRequest typeRequest) {
        OrderFieldResponse orderFieldResponse = new OrderFieldResponse();
        //类型
        List<String> fieldsName = new ArrayList<>();
        //添加种类
        String fields[] = {"订单笔数", "成交量", "成交金额", "人均消费"};
        fieldsName = Arrays.asList(fields);
        orderFieldResponse.setFieldsName(fieldsName);
        //数值和字段
        List<SeriesDataResponse> seriesData = new ArrayList<>();
        //今日的统计
        if (typeRequest.getType().equals(OrderSumEnum.TODAY.getCode())) {
            List<String> hours = OperatCenterTimeUtil.getHours();
            orderFieldResponse.setXAxisData(hours);
            List<OrderSumResponse> orderSumResponseList = dzAddonShopOrderMapper.getToday();
            //时间
            if (!CollectionUtils.isEmpty(orderSumResponseList)) {
                Map<String,List<BigDecimal>> seriesMap = new HashMap<>();
                for (int i = 0; i < fieldsName.size(); i++) {
                    seriesMap.put(fieldsName.get(i),new ArrayList<>());
                }
                //封装成map,用时间作为key
                Map<String, OrderSumResponse> map = orderSumResponseList.stream().collect(Collectors.toMap(item -> item.getTime(), item -> item));
                //时间匹配
                for (String hour : hours) {
                    if(map.get(hour)!=null){
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            if(fieldsName.get(i).equals("订单笔数")){
                                list.add(BigDecimal.valueOf(map.get(hour).getCount()));
                            }else if(fieldsName.get(i).equals("成交量")){
                                list.add(BigDecimal.valueOf(map.get(hour).getProductCount()));
                            }else if(fieldsName.get(i).equals("成交金额")){
                                list.add(map.get(hour).getPayMoney());
                            }else if(fieldsName.get(i).equals("人均消费")){
                                list.add(map.get(hour).getAvgMoney());
                            }
                            seriesMap.put(fieldsName.get(i),list);
                        }
                    }else{
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            list.add(new BigDecimal(0));
                            seriesMap.put(fieldsName.get(i),list);
                        }
                    }
                }
                for(String key : seriesMap.keySet()){
                    SeriesDataResponse seriesDataResponse = new SeriesDataResponse();
                    seriesDataResponse.setName(key);
                    seriesDataResponse.setData(seriesMap.get(key));
                    seriesData.add(seriesDataResponse);
                }
                orderFieldResponse.setSeriesData(seriesData);
            } else {
                //没有数据
                //成交量
                //匹配
                for (int i = 0; i < fieldsName.size(); i++) {
                    SeriesDataResponse seriesDataResponseProductCount = new SeriesDataResponse();
                    if (fieldsName.get(i).equals("成交量")) {
                        seriesDataResponseProductCount.setName("成交量");
                    } else if (fieldsName.get(i).equals("订单笔数")) {
                        seriesDataResponseProductCount.setName("订单笔数");
                    } else if (fieldsName.get(i).equals("成交金额")) {
                        seriesDataResponseProductCount.setName("成交金额");
                    } else if (fieldsName.get(i).equals("人均消费")) {
                        seriesDataResponseProductCount.setName("人均消费");
                    }
                    List<BigDecimal> dataProductCount = new ArrayList<>();
                    //没有数据，将所有点位数据初始化为0
                    for (String hour : hours) {
                        dataProductCount.add(new BigDecimal(0));
                    }
                    seriesDataResponseProductCount.setData(dataProductCount);
                    seriesData.add(seriesDataResponseProductCount);
                }
                orderFieldResponse.setSeriesData(seriesData);
            }

        } else if (typeRequest.getType().equals(OrderSumEnum.YESTERDAY.getCode())) {
            //昨天
            orderFieldResponse.setXAxisData(OperatCenterTimeUtil.getHours());
            List<OrderSumResponse> orderSumResponseList = dzAddonShopOrderMapper.getYesterday();
            List<String> hours = OperatCenterTimeUtil.getHours();
            if (!CollectionUtils.isEmpty(orderSumResponseList)) {
                Map<String,List<BigDecimal>> seriesMap = new HashMap<>();
                for (int i = 0; i < fieldsName.size(); i++) {
                    seriesMap.put(fieldsName.get(i),new ArrayList<>());
                }
                //封装成map,用时间作为key
                Map<String, OrderSumResponse> map = orderSumResponseList.stream().collect(Collectors.toMap(item -> item.getTime(), item -> item));
                //时间匹配
                for (String hour : hours) {
                    if(map.get(hour)!=null){
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            if(fieldsName.get(i).equals("订单笔数")){
                                list.add(BigDecimal.valueOf(map.get(hour).getCount()));
                            }else if(fieldsName.get(i).equals("成交量")){
                                list.add(BigDecimal.valueOf(map.get(hour).getProductCount()));
                            }else if(fieldsName.get(i).equals("成交金额")){
                                list.add(map.get(hour).getPayMoney());
                            }else if(fieldsName.get(i).equals("人均消费")){
                                list.add(map.get(hour).getAvgMoney());
                            }
                            seriesMap.put(fieldsName.get(i),list);
                        }
                    }else{
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            list.add(new BigDecimal(0));
                            seriesMap.put(fieldsName.get(i),list);
                        }
                    }
                }
                for(String key : seriesMap.keySet()){
                    SeriesDataResponse seriesDataResponse = new SeriesDataResponse();
                    seriesDataResponse.setName(key);
                    seriesDataResponse.setData(seriesMap.get(key));
                    seriesData.add(seriesDataResponse);
                }
                orderFieldResponse.setSeriesData(seriesData);
            }else{
                for (int i = 0; i < fieldsName.size(); i++) {
                    SeriesDataResponse seriesDataResponseProductCount = new SeriesDataResponse();
                    if (fieldsName.get(i).equals("成交量")) {
                        seriesDataResponseProductCount.setName("成交量");
                    } else if (fieldsName.get(i).equals("订单笔数")) {
                        seriesDataResponseProductCount.setName("订单笔数");
                    } else if (fieldsName.get(i).equals("成交金额")) {
                        seriesDataResponseProductCount.setName("成交金额");
                    } else if (fieldsName.get(i).equals("人均消费")) {
                        seriesDataResponseProductCount.setName("人均消费");
                    }
                    List<BigDecimal> dataProductCount = new ArrayList<>();
                    //没有数据，将所有点位数据初始化为0
                    for (String hour : hours) {
                        dataProductCount.add(new BigDecimal(0));
                    }
                    seriesDataResponseProductCount.setData(dataProductCount);
                    seriesData.add(seriesDataResponseProductCount);
                    orderFieldResponse.setSeriesData(seriesData);
                }
                orderFieldResponse.setSeriesData(seriesData);
            }
        } else if (typeRequest.getType().equals(OrderSumEnum.WEEK.getCode())) {
            //本周
            orderFieldResponse.setXAxisData(OperatCenterTimeUtil.getWeekDay());
            List<OrderSumResponse> orderSumResponseList = dzAddonShopOrderMapper.getWeek();
            if (!CollectionUtils.isEmpty(orderSumResponseList)) {
                Map<String, List<BigDecimal>> seriesMap = new HashMap<>();
                for (int i = 0; i < fieldsName.size(); i++) {
                    seriesMap.put(fieldsName.get(i), new ArrayList<>());
                }
                //封装成map,用时间作为key
                Map<String, OrderSumResponse> map = orderSumResponseList.stream().collect(Collectors.toMap(item -> item.getTime(), item -> item));
                //时间匹配
                for (String day : OperatCenterTimeUtil.getWeekDay()) {
                    if (map.get(day) != null) {
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            if (fieldsName.get(i).equals("订单笔数")) {
                                list.add(BigDecimal.valueOf(map.get(day).getCount()));
                            } else if (fieldsName.get(i).equals("成交量")) {
                                list.add(BigDecimal.valueOf(map.get(day).getProductCount()));
                            } else if (fieldsName.get(i).equals("成交金额")) {
                                list.add(map.get(day).getPayMoney());
                            } else if (fieldsName.get(i).equals("人均消费")) {
                                list.add(map.get(day).getAvgMoney());
                            }
                            seriesMap.put(fieldsName.get(i), list);
                        }
                    } else {
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            list.add(new BigDecimal(0));
                            seriesMap.put(fieldsName.get(i), list);
                        }
                    }
                }
                for (String key : seriesMap.keySet()) {
                    SeriesDataResponse seriesDataResponse = new SeriesDataResponse();
                    seriesDataResponse.setName(key);
                    seriesDataResponse.setData(seriesMap.get(key));
                    seriesData.add(seriesDataResponse);
                }
                orderFieldResponse.setSeriesData(seriesData);
            } else {
                for (int i = 0; i < fieldsName.size(); i++) {
                    SeriesDataResponse seriesDataResponseProductCount = new SeriesDataResponse();
                    if (fieldsName.get(i).equals("成交量")) {
                        seriesDataResponseProductCount.setName("成交量");
                    } else if (fieldsName.get(i).equals("订单笔数")) {
                        seriesDataResponseProductCount.setName("订单笔数");
                    } else if (fieldsName.get(i).equals("成交金额")) {
                        seriesDataResponseProductCount.setName("成交金额");
                    } else if (fieldsName.get(i).equals("人均消费")) {
                        seriesDataResponseProductCount.setName("人均消费");
                    }
                    List<BigDecimal> dataProductCount = new ArrayList<>();
                    //没有数据，将所有点位数据初始化为0
                    for (String hour : OperatCenterTimeUtil.getWeekDay()) {
                        dataProductCount.add(new BigDecimal(0));
                    }
                    seriesDataResponseProductCount.setData(dataProductCount);
                    seriesData.add(seriesDataResponseProductCount);
                }
                orderFieldResponse.setSeriesData(seriesData);
            }
        } else if (typeRequest.getType().equals(OrderSumEnum.MONTH.getCode())) {
            //本月
            orderFieldResponse.setXAxisData(OperatCenterTimeUtil.getMonthDay());
            List<OrderSumResponse> orderSumResponseList = dzAddonShopOrderMapper.getMonth();
            if (!CollectionUtils.isEmpty(orderSumResponseList)) {
                Map<String,List<BigDecimal>> seriesMap = new HashMap<>();
                for (int i = 0; i < fieldsName.size(); i++) {
                    seriesMap.put(fieldsName.get(i),new ArrayList<>());
                }
                //封装成map,用时间作为key
                Map<String, OrderSumResponse> map = orderSumResponseList.stream().collect(Collectors.toMap(item -> item.getTime(), item -> item));
                //时间匹配
                for (String day : OperatCenterTimeUtil.getMonthDay()) {
                    if(map.get(day)!=null){
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            if(fieldsName.get(i).equals("订单笔数")){
                                list.add(BigDecimal.valueOf(map.get(day).getCount()));
                            }else if(fieldsName.get(i).equals("成交量")){
                                list.add(BigDecimal.valueOf(map.get(day).getProductCount()));
                            }else if(fieldsName.get(i).equals("成交金额")){
                                list.add(map.get(day).getPayMoney());
                            }else if(fieldsName.get(i).equals("人均消费")){
                                list.add(map.get(day).getAvgMoney());
                            }
                            seriesMap.put(fieldsName.get(i),list);
                        }
                    }else{
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            list.add(new BigDecimal(0));
                            seriesMap.put(fieldsName.get(i),list);
                        }
                    }
                }
                for(String key : seriesMap.keySet()){
                    SeriesDataResponse seriesDataResponse = new SeriesDataResponse();
                    seriesDataResponse.setName(key);
                    seriesDataResponse.setData(seriesMap.get(key));
                    seriesData.add(seriesDataResponse);
                }
                orderFieldResponse.setSeriesData(seriesData);
            }else{
                for (int i = 0; i < fieldsName.size(); i++) {
                    SeriesDataResponse seriesDataResponseProductCount = new SeriesDataResponse();
                    if (fieldsName.get(i).equals("成交量")) {
                        seriesDataResponseProductCount.setName("成交量");
                    } else if (fieldsName.get(i).equals("订单笔数")) {
                        seriesDataResponseProductCount.setName("订单笔数");
                    } else if (fieldsName.get(i).equals("成交金额")) {
                        seriesDataResponseProductCount.setName("成交金额");
                    } else if (fieldsName.get(i).equals("人均消费")) {
                        seriesDataResponseProductCount.setName("人均消费");
                    }
                    List<BigDecimal> dataProductCount = new ArrayList<>();
                    //没有数据，将所有点位数据初始化为0
                    for (String hour : OperatCenterTimeUtil.getMonthDay()) {
                        dataProductCount.add(new BigDecimal(0));
                    }
                    seriesDataResponseProductCount.setData(dataProductCount);
                    seriesData.add(seriesDataResponseProductCount);
                }
                orderFieldResponse.setSeriesData(seriesData);
            }
        } else if (typeRequest.getType().equals(OrderSumEnum.YEAR.getCode())) {
            //本年
            orderFieldResponse.setXAxisData(OperatCenterTimeUtil.getYearMonth());
            List<OrderSumResponse> orderSumResponseList = dzAddonShopOrderMapper.getYear();
            if (!CollectionUtils.isEmpty(orderSumResponseList)) {
                Map<String, List<BigDecimal>> seriesMap = new HashMap<>();
                for (int i = 0; i < fieldsName.size(); i++) {
                    seriesMap.put(fieldsName.get(i), new ArrayList<>());
                }
                //封装成map,用时间作为key
                Map<String, OrderSumResponse> map = orderSumResponseList.stream().collect(Collectors.toMap(item -> item.getTime(), item -> item));
                //时间匹配
                for (String day : OperatCenterTimeUtil.getYearMonth()) {
                    if (map.get(day) != null) {
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            if (fieldsName.get(i).equals("订单笔数")) {
                                list.add(BigDecimal.valueOf(map.get(day).getCount()));
                            } else if (fieldsName.get(i).equals("成交量")) {
                                list.add(BigDecimal.valueOf(map.get(day).getProductCount()));
                            } else if (fieldsName.get(i).equals("成交金额")) {
                                list.add(map.get(day).getPayMoney());
                            } else if (fieldsName.get(i).equals("人均消费")) {
                                list.add(map.get(day).getAvgMoney());
                            }
                            seriesMap.put(fieldsName.get(i), list);
                        }
                    } else {
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            list.add(new BigDecimal(0));
                            seriesMap.put(fieldsName.get(i), list);
                        }
                    }
                }
                for (String key : seriesMap.keySet()) {
                    SeriesDataResponse seriesDataResponse = new SeriesDataResponse();
                    seriesDataResponse.setName(key);
                    seriesDataResponse.setData(seriesMap.get(key));
                    seriesData.add(seriesDataResponse);
                }
                orderFieldResponse.setSeriesData(seriesData);
            } else {
                for (int i = 0; i < fieldsName.size(); i++) {
                    SeriesDataResponse seriesDataResponseProductCount = new SeriesDataResponse();
                    if (fieldsName.get(i).equals("成交量")) {
                        seriesDataResponseProductCount.setName("成交量");
                    } else if (fieldsName.get(i).equals("订单笔数")) {
                        seriesDataResponseProductCount.setName("订单笔数");
                    } else if (fieldsName.get(i).equals("成交金额")) {
                        seriesDataResponseProductCount.setName("成交金额");
                    } else if (fieldsName.get(i).equals("人均消费")) {
                        seriesDataResponseProductCount.setName("人均消费");
                    }
                    List<BigDecimal> dataProductCount = new ArrayList<>();
                    //没有数据，将所有点位数据初始化为0
                    for (String hour : OperatCenterTimeUtil.getYearMonth()) {
                        dataProductCount.add(new BigDecimal(0));
                    }
                    seriesDataResponseProductCount.setData(dataProductCount);
                    seriesData.add(seriesDataResponseProductCount);
                }
                orderFieldResponse.setSeriesData(seriesData);
            }
        } else if (typeRequest.getType().equals(OrderSumEnum.LAST_YEAR.getCode())) {
            //去年
            orderFieldResponse.setXAxisData(OperatCenterTimeUtil.getLastYearMonth());
            List<OrderSumResponse> orderSumResponseList = dzAddonShopOrderMapper.getLastYear();
            if (!CollectionUtils.isEmpty(orderSumResponseList)) {
                Map<String, List<BigDecimal>> seriesMap = new HashMap<>();
                for (int i = 0; i < fieldsName.size(); i++) {
                    seriesMap.put(fieldsName.get(i), new ArrayList<>());
                }
                //封装成map,用时间作为key
                Map<String, OrderSumResponse> map = orderSumResponseList.stream().collect(Collectors.toMap(item -> item.getTime(), item -> item));
                //时间匹配
                for (String day : OperatCenterTimeUtil.getLastYearMonth()) {
                    if (map.get(day) != null) {
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            if (fieldsName.get(i).equals("订单笔数")) {
                                list.add(BigDecimal.valueOf(map.get(day).getCount()));
                            } else if (fieldsName.get(i).equals("成交量")) {
                                list.add(BigDecimal.valueOf(map.get(day).getProductCount()));
                            } else if (fieldsName.get(i).equals("成交金额")) {
                                list.add(map.get(day).getPayMoney());
                            } else if (fieldsName.get(i).equals("人均消费")) {
                                list.add(map.get(day).getAvgMoney());
                            }
                            seriesMap.put(fieldsName.get(i), list);
                        }
                    } else {
                        for (int i = 0; i < fieldsName.size(); i++) {
                            List<BigDecimal> list = seriesMap.get(fieldsName.get(i));
                            list.add(new BigDecimal(0));
                            seriesMap.put(fieldsName.get(i), list);
                        }
                    }
                }
                for (String key : seriesMap.keySet()) {
                    SeriesDataResponse seriesDataResponse = new SeriesDataResponse();
                    seriesDataResponse.setName(key);
                    seriesDataResponse.setData(seriesMap.get(key));
                    seriesData.add(seriesDataResponse);
                }
                orderFieldResponse.setSeriesData(seriesData);
            } else {
                for (int i = 0; i < fieldsName.size(); i++) {
                    SeriesDataResponse seriesDataResponseProductCount = new SeriesDataResponse();
                    if (fieldsName.get(i).equals("成交量")) {
                        seriesDataResponseProductCount.setName("成交量");
                    } else if (fieldsName.get(i).equals("订单笔数")) {
                        seriesDataResponseProductCount.setName("订单笔数");
                    } else if (fieldsName.get(i).equals("成交金额")) {
                        seriesDataResponseProductCount.setName("成交金额");
                    } else if (fieldsName.get(i).equals("人均消费")) {
                        seriesDataResponseProductCount.setName("人均消费");
                    }
                    List<BigDecimal> dataProductCount = new ArrayList<>();
                    //没有数据，将所有点位数据初始化为0
                    for (String hour : OperatCenterTimeUtil.getLastYearMonth()) {
                        dataProductCount.add(new BigDecimal(0));
                    }
                    seriesDataResponseProductCount.setData(dataProductCount);
                    seriesData.add(seriesDataResponseProductCount);
                }
                orderFieldResponse.setSeriesData(seriesData);
            }
        }
        return orderFieldResponse;
    }

总结

统计图

ljs6281123
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用ECharts实现各种数据统计图（饼图，柱状图，折线图）在javaWeb中的应用
dll322的博客
07-27 1万+
具体的资源及页面代码在后文可下载 准备工作：要下载ECharts的源文件 第一步：在web端既新建一个jsp页面 第二步：引入ECharts的js 第三步：为ECharts准备一个具备大小（宽高）的容器 第四部：为模块加载器配置echarts的路径，从当前页面链接到echarts.js，定义所需图表路径 第五步：动态加载echarts然后
java实现各种数据统计图（柱形图，饼图，折线图）
as6669213的专栏
12-24 5287
最近在做数据挖掘的课程设计，需要将数据分析的结果很直观的展现给用户，这就要用到数据统计图，要实现这个功能就需要几个第三方包了： 1.       jfreechart-1.0.13.jar 2.       jcommon-1.0.16.jar 3.       gnujaxp.jar   先来看一下，最终效果图：   主要是jfreechart-1.0.13.jar，但这三个包
java 后台生成echarts 图片
最新发布
weixin_40721590的博客
07-10 199
如何在Java后台生成echarts图片 介绍 作为一名经验丰富的开发者，我会教你如何在Java后台生成echarts图片。这对于刚入行的小白可能有些困难，但是按照下面的步骤，你会很快学会的。 流程 首先，让我们来看一下整个实现的流程： erDiagram 确定需求 --> 下载echarts库 下载...
java中echarts的使用
AnSirTechnology的博客
02-23 2840
echarts这个插件解决了用Java语言画曲线图难的问题 1.第一步先从后台传来两个json字符串一个是y轴的数值一个为x轴的数值，如例： [‘老年人’,‘儿童’,‘妇女’,‘高血压’,‘糖尿病’,‘精神病’,‘冠心病’] [0,6,1,7,6,4,4] 2.页面上css中添加 #main{ text-align: center; width: 70%; height:70%; marg...
JAVA集成echars生成折线图
weixin_48041611的博客
03-28 640
java后端集成echars生成多条折线图并保存本地,echars生成图片的标题和图表重合，重叠，固定echars生成图片的Y轴的上下限的值，echars生成图片的图标颜色和线条颜色及加粗设置
Java调用Echarts3简单封装及示例
06-07
为方便在开发中使用Echart3输出图形，对其进行了简单的封装。
JAVA 开源类库 绘制统计图 JFreeChart
tangwing的专栏
06-17 895
<br /> <br />    最近由于项目需要，要绘制统计图。偶然的机会发现了一个已有的开源类库——JFreeChart。用了用，感觉，怎么说呢。。。太强了！通过简单地调用API，可以轻易画出上百种类型的统计图！<br />    象征性地截个图给大家看：<br /> <br />    <br />    详细信息去相关网站吧：http://www.jfree.org/jfreechart/。<br />    顺便说一句，大家要重视开发时的重用哈～sourceforge真是个好地方！
java-echart.js柱状图、饼状图、折线图
01-03
java-echart.js柱状图、饼状图、折线图 /** * 柱状图 * @param classRoom * @param req * @param resp * @param model * @return */ @RequestMapping(value = "/zhuzhuangtu") public String ...
Echarts+ajax+java+mysql实现饼图+折线图+柱状图
07-13
Echarts是一款由百度开发的开源JavaScript图表库，它提供了丰富的可视化图表类型，包括但不限于饼图、折线图和柱状图。在这个项目中，Echarts与AJAX和Java后端结合，利用MySQL数据库来实现动态的数据展示。接下来，...
Springboot+mybatis+echarts实现数据可视化 折线图饼图柱状图
06-22
在这个项目中，我们将探讨如何使用Springboot、Mybatis和Echarts这三种技术来实现数据的可视化，包括折线图、饼图和柱状图。这些图表类型广泛用于数据分析、报表展示和决策支持。 首先，Springboot是基于Spring框架...
java-echart.js柱状图、饼状图、折线图添加了 折线图
04-15
通过这种方式，你可以在Java后端生成ECharts配置，然后在前端页面动态绘制出柱状图、饼状图和折线图，实现数据可视化的高效开发。同时，ECharts的灵活性和强大功能使得可以根据需求进行复杂的图表定制。
java实现Echarts折线图历史数据显示（一）
04-29
JDBC实现MySQL中的数据上传到前端，经Echarts折线图展示出来。
ECharts-java 的使用demo
11-13
听说百度的ECharts非常强大，闲来没事，写了一个demo尝试了一下，需要的朋友可以下载看看，希望对你有帮助。
java应用百度echarts(项目例子)
01-30
详细说明请看http://blog.csdn.net/weixin_39549656/article/details/79208930
基于java的echart实例
10-16
基于echart的图形报表实例，欢迎各位下载！
JAVAEE细细看 框架24 - ECharts 折线图
ZMW_IOS的博客
05-04 542
ECharts ECharts缩写来自Enterprise Charts，商业级数据图表，是百度的一个开源的使用JavaScript实现的数据可视化工具， 官网：https://echarts.baidu.com/ 下载地址：https://echarts.baidu.com/download.html // 使用 echarts.min.js 下载完成可以得到如下文件： 解压zip文件，我们只需...
java组装echarts的折线图
m0_50843430的博客
01-12 1233
java组装echarts的折线图
java——插件echarts数据可视化图表库
weixin_42858422的博客
09-17 9608
插件echarts数据可视化图表库一、使用idea创建javaWeb工程二、下载echarts导入js文件三、使用echarts。————————创作不易，如觉不错，随手三连点赞，收藏，关注，谢谢~~ 一、使用idea创建javaWeb工程 创建工程，因为我这里已经配置好JDK跟Tomcat服务器了，就直接选择了。 下一步 下一步 项目创建完成了只后，我们创建两个文件夹，分别用来存放编译后的文件，跟jar包 接着，我们对着两个包进行配置，首先配置classes，选择classes的位置 下一步，接
使用Java实现Echarts数据可视化
GnqEditor的博客
09-17 1683
通过引入Echarts的依赖项，并使用Java代码创建图表的配置项，我们可以将图表数据传递给前端，并使用Echarts的JavaScript库将其渲染成交互式的图表。Echarts是一种强大的数据可视化库，它提供了丰富的图表类型和交互功能，可以帮助我们更好地展示和分析数据。在Java中，我们可以使用Echarts来创建各种图表，并将其嵌入到我们的应用程序中。如果你对其他类型的图表或更高级的功能感兴趣，可以查阅Echarts官方文档，其中提供了更详细的API和示例代码。对象，然后设置了图表的标题和副标题。
react echart 柱状折线图
05-31
要在 React 中使用 ECharts 来绘制柱状折线图，可以按照以下步骤进行： 1. 安装 ECharts 库 使用 npm 命令安装 ECharts 库，命令如下： ``` npm install echarts --save ``` 2. 导入 ECharts 库 在需要使用 ECharts 的组件中，通过 import 语句导入 ECharts 库，代码如下： ```javascript import echarts from 'echarts'; ``` 3. 创建 ECharts 实例 在组件的 componentDidMount 生命周期中，通过 ref 获取容器元素，然后创建 ECharts 实例，代码如下： ```javascript componentDidMount() { const { data } = this.props; const chartDom = this.refs.chart; const myChart = echarts.init(chartDom); // 绘制图表 myChart.setOption({ // 配置项 }); } ``` 4. 配置图表 在 setOption 方法中，可以配置图表的各种属性，包括标题、坐标轴、数据系列等，代码如下： ```javascript myChart.setOption({ title: { text: '柱状折线图示例' }, legend: { data: ['销量', '利润'] }, tooltip: {}, xAxis: { data: ['衬衫', '羊毛衫', '雪纺衫', '裤子', '高跟鞋', '袜子'] }, yAxis: [ { type: 'value', name: '销量（件）' }, { type: 'value', name: '利润（元）' } ], series: [ { name: '销量', type: 'bar', data: [5, 20, 36, 10, 10, 20] }, { name: '利润', type: 'line', yAxisIndex: 1, data: [10, 30, 50, 20, 20, 30] } ] }); ``` 以上代码配置了一个带有标题、图例、提示框、两个坐标轴、柱状系列和折线系列的柱状折线图。 5. 渲染图表 最后，在 render 方法中，渲染一个 div 容器，并通过 ref 属性指定其引用，代码如下： ```javascript render() { return ( <div ref="chart" style={{ width: '100%', height: '400px' }}></div> ); } ``` 这样，就可以在 React 中使用 ECharts 绘制柱状折线图了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值