精华内容
下载资源
问答
  • java实现Excel动态列导出的简单例子

    千次阅读 2020-05-16 16:39:48
    可以通过该对象的set方法设置各个参数,headKey保存结果集中,数据对应的key值,ArrayList最佳,保证了导出列的顺序,同时限制了每个sheet页保存的最大数据行数为5W条,这些参数也可以放到属性中进行设置。...

    可以通过该对象的set方法设置各个参数,headKey保存结果集中,数据对应的key值,ArrayList最佳,保证了导出列的顺序,同时限制了每个sheet页保存的最大数据行数为5W条,这些参数也可以放到属性中进行设置。

    @Data
    public class ExcelExportUtil {
    
        //表头
        private String title;
        //各个列的表头
        private List<String> headList;
        //各个列的元素key值
        private List<String> headKey;
        // 各个列的宽度
        private List<Integer> headWidth;
        //需要填充的数据信息
        private List<HashMap> data;
        //字体大小
        private int fontSize = 14;
        //行高
        private int rowHeight = 30;
        //列宽
        private int columWidth = 200;
        //工作表
        private String sheetName = "sheet";
        // 文件名
        private String fileName;
    
        HSSFWorkbook wb;
    
        HSSFSheet sheet;
    
        HSSFCellStyle headCellStyle;
    
        HttpServletResponse response;
    
        public ExcelExportUtil exportExport(HttpServletResponse response) throws IOException {
            this.response = response;
            wb = new HSSFWorkbook();
            int size = data.size();
            int count = (size - 1) / 50000 + 1;
            for (int i = 0; i < count; i++) {
                sheet = wb.createSheet(sheetName + (i + 1));
                exportExport(sheet,
                        data.subList(i * 50000, ((i + 1) * 50000 > size ? size : 50000 * (i + 1))));
            }
            return this;
        }
    
        private void exportExport(HSSFSheet sheet, List<HashMap> data) throws IOException{
    
            //检查参数配置信息
            checkConfig();
            HSSFCellStyle cellStyle = wb.createCellStyle();
            HSSFDataFormat format = wb.createDataFormat();
            //这样才能真正的控制单元格格式,@就是指文本型
            cellStyle.setDataFormat(format.getFormat("@"));
    
            HSSFRow headRow = sheet.createRow(0);
            //设置列头元素
            for (int i = 0; i < headList.size(); i++) {
                Integer width = 15;
                if (headWidth != null && headWidth.size() >= headList.size()){
                    width = headWidth.get(i);
                }
                sheet.setColumnWidth(i, 256 * width + 184);
                HSSFCell cellHead = headRow.createCell(i);
                cellHead.setCellValue(headList.get(i));
                cellHead.setCellStyle(headCellStyle);
            }
    
            //开始写入实体数据信息
            int a = 1;
            for (int i = 0; i < data.size(); i++) {
                HSSFRow row = sheet.createRow(a);
                HashMap map = data.get(i);
                HSSFCell cell;
                for (int j = 0; j < headKey.size(); j++) {
                    cell = row.createCell(j);
                    Object valueObject = map.get(headKey.get(j));
                    if (valueObject == null) {
                        valueObject = "";
                    }
                    if (valueObject instanceof Integer) {
                        //取出的数据是Integer
                        cell.setCellValue(((Integer) (valueObject)).floatValue());
                    } else if (valueObject instanceof BigDecimal) {
                        //取出的数据是BigDecimal
                        cell.setCellValue(((BigDecimal) (valueObject)).floatValue());
                    } else {
                        //取出的数据是字符串直接赋值
                        cell.setCellStyle(cellStyle);
                        cell.setCellValue(Strings.isNullOrEmpty(String.valueOf(valueObject)) ? "" : String.valueOf(valueObject));
                    }
                }
                a++;
            }
        }
    
        public void flushExplorer() throws Exception{
            // 告诉浏览器用什么软件可以打开此文件
            response.setHeader("content-Type", "application/vnd.ms-excel");
            // 下载文件的默认名称
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName + ".xls", "utf-8"));
            wb.write(response.getOutputStream());
        }
    
        /**
         * 检查数据配置问题
         *
         * @throws IOException 抛出数据异常类
         */
        protected void checkConfig() throws IOException {
            if (headKey == null) {
                throw new IOException("表头不能为空");
            }
    
            if (headWidth != null && headWidth.size() < headKey.size()){
                throw new IOException("设置宽度的列数必须超过表头列数");
            }
    
            if (fontSize < 0 || rowHeight < 0 || columWidth < 0) {
                throw new IOException("字体、宽度或者高度不能为负值");
            }
    
            if (Strings.isNullOrEmpty(sheetName)) {
                throw new IOException("工作表表名不能为NULL");
            }
            createDefaultHeadStyle();
        }
    
        public void createDefaultHeadStyle() {
            //创建表头样式
            headCellStyle= wb.createCellStyle();
            //居中
            headCellStyle.setAlignment(HorizontalAlignment.LEFT);
            //背景色
            headCellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
            headCellStyle.setFillForegroundColor(HSSFColor.HSSFColorPredefined.PALE_BLUE.getIndex());
    
            //字体
            HSSFFont font = wb.createFont();
            font.setFontHeightInPoints((short)12);
            font.setBold(true);         //字体增粗
            headCellStyle.setFont(font);
    
            headCellStyle.setBorderBottom(BorderStyle.THIN); // 下边框
            headCellStyle.setBorderLeft(BorderStyle.THIN);// 左边框
            headCellStyle.setBorderTop(BorderStyle.THIN);// 上边框
            headCellStyle.setBorderRight(BorderStyle.THIN);// 右边框
        }
    }
    
    

    简单的调用例子:

    		ExcelExportUtil excelExportUtil = new ExcelExportUtil();
    		// 表头固定列
            List<String> headList = new ArrayList<>();
            headList.add("省");
            if (param.getCity() != 0){
                headList.add("市");
            }
    
            // 表头固定key
            List<String> headKey = new ArrayList<>();
            headKey.add("province");
            if (param.getCity() != 0){
                headKey.add("city");
            }
    
            for (HashMap dateInfo : date){
                for (String key : param.getNeedType()){
                    headList.add(dateInfo.get("day") + "日" + ConstantUtils.NEED_MAP.get(key));
                    headKey.add(dateInfo.get("day") + "_" + key);
                }
            }
    
            excelExportUtil.setHeadList(headList);
            excelExportUtil.setHeadKey(headKey);
            excelExportUtil.setData(list);
            excelExportUtil.setFileName("XXX日账");
            excelExportUtil.exportExport(response).flushExplorer();
    
    展开全文
  • 标题说的很清楚,利用asm-3.1.jar,cglib-2.2.jar,commons-io-1.3.2.jar,poi-3.9-20121203.jar 开发的一个工具包。 其中用到字节码编码,反射,excel操作。...主要功能1、自定义列导出excel Main()类为测试用例
  • EasyPoi动态列导出Excel

    千次阅读 2020-01-18 15:10:07
    我心想很简单呀,不就是建个实体类,添加@Excel注解喽,然后直接导出不就行了。 **PS:**实体类的字段名就是上面的这个公司(有一名字叫公司,这个公司也是一家公司,不是用作区分的,你可以把这个公司理解为...

    最近有一个项目,项目中涉及到一张报表,领导给了个格式大概如下图所示
    在这里插入图片描述
    刚看到这格式,怎么说呢。我心想很简单呀,不就是建个实体类,添加@Excel注解喽,然后直接导出不就行了。
    **PS:**实体类的字段名就是上面的这个公司(有一列名字叫公司,这个公司也是一家公司,不是用作区分的,你可以把这个公司理解为“公司aaa”,跟后面那些是一样的)。

    然而领导说,这个上面的公司,也就是列名数量不固定,不确定有多少,也就是动态显示的。wdmmd?这是什么操作,我吃了一惊。
    在这里插入图片描述
    这里先建议大家看一下EasyPoi的官方文档,有兴趣的可以大概过一遍。没兴趣的直接往下看

    先讲一下思路,我一开始想到的就是动态创建实体类,动态创建属性值,加入get和set方法。理论上是可行的,不过网上教程挺少的,所以我找了一遍就想有没有别的方法。

    于是在官网找到了这么一段话
    在这里插入图片描述
    简单来说就是把原来的实体类属性换成Map的key,也就是吧Map<Key,value>中的key当做类的属性,也就是我们所要的动态列名。ok,问题完美解决了。
    下面就是定一下源数据的格式,用于处理成所需的样式。
    在这里插入图片描述
    上面是我的实体类字段

    在这里插入图片描述
    这个是我造的一些数据。动态列名就是那个companies。这个数据哪里来呢?就是从上面的数据中提取出来的不重复公司,这个应该能理解吧。那怎么提取,方法有很多,我就不具体讲了。你可以从数据库取到这些数据的时候,再在数据外面套一层
    select distinct company from(你查询出结果的语句)t
    这样不就获取到数据中不重复的公司了吗
    那这样,数据准备好了,动态列名准备好了。下面的你总该会了吧。
    在这里插入图片描述
    在这里插入图片描述
    这就是我最后做出来的成果了。有一些难点就比如说指定行和列的合并单元格,网上找了好久没找到,后来还是自己去翻文档找到的。还有就是纵向合并的单元格(这个有现成方法,但是你要保证你所有一样的数据都在一起,这里就涉及到排序了)
    这里的横竖两个合计也是我用代码动态计算后创建出来的。

    需要代码的留言,或私信我(除非必要,代码我贴了一部分出来了,实在解决不了再来问,谢谢),看到会回复。在这里插入图片描述

    展开全文
  • 使用easypoi导出excel实现动态列

    万次阅读 热门讨论 2019-03-01 10:41:20
    使用easypoi导出excel实现动态列 说明: 使用的是easypoi进行导出 行头是动态生成 依据key进行匹配,进行数据填充 第一进行纵向动态合并 自己的一个使用,记录一下 实现效果 变更前样式 变更后样式 代码解析...

    使用easypoi导出excel实现动态列

    说明

    使用的是easypoi进行导出
    行头是动态生成
    依据key进行列匹配,进行数据填充
    第一列进行纵向动态合并
    自己的一个使用,记录一下

    工具依赖

    <dependency>
    	   <groupId>cn.afterturn</groupId>
    	  <artifactId>easypoi-base</artifactId>
    	  <version>3.2.0</version>
    </dependency>
    <dependency>
    	   <groupId>cn.afterturn</groupId>
    	  <artifactId>easypoi-annotation</artifactId>
    	  <version>3.2.0</version>
    </dependency>
    <dependency>
    	   <groupId>cn.afterturn</groupId>
    	  <artifactId>easypoi-web</artifactId>
    	  <version>3.2.0</version>
    </dependency>
    

    实现效果

    变更前样式
    变更前数据样式
    变更后样式在这里插入图片描述

    代码解析

    动态生成列头

      private List<ExcelExportEntity> dynamicNewAddExcel(Map<String, PlatformStatisParamRespData> paramInfo) {
      	//表头的集合,用于添加表头
        List<ExcelExportEntity> entityList = new ArrayList<>();
    
    	//ExcelExportEntity构造参数【第一个是列名头的统计字段,第二个是需要指定的一个key在填充数据的时候是需要根据这个key进行填充值,第三个参数是列宽】
        ExcelExportEntity platformXh = new ExcelExportEntity("统计字段1", "statisKey1", 30);
        //列的合并(纵向列的同名称会进行合并,效果见上图的平台名称的变化)
        platformXh.setMergeVertical(true);
        entityList.add(platformXh);
    
        ExcelExportEntity statisDateXh = new ExcelExportEntity("统计字段2", "statisKey2", 30);
        entityList.add(statisDateXh);
    
        //参数信息--[用于动态拼接列头]
        final Iterator<String> iterator = paramInfo.keySet().iterator();
        while (iterator.hasNext()) {
          final String paramKeyStr = iterator.next();
          final String paramNameStr = paramInfo.get(paramKeyStr).getDataName();
          //列头由参数汉字名称,参数key为列key
          entityList.add(new ExcelExportEntity(paramNameStr, paramKeyStr, 30));
        }
        return entityList;
      }
    

    动态填充数据

    private List<Map<String, Object>> dynamicListDataByKey(List<PlatformIncomeRespDTO> statisData) {
        //参数类型
        final Set<String> statisParamKey = statisData.get(0).getParamInfo().keySet();
        final List<String> statisDate = statisData.get(0).getStatisDate();
        final int platformNum = statisData.size();
    
        //最终的数据
        List<Map<String, Object>> datas = new ArrayList<>();
        for (int i = 0; i < platformNum; i++) {
          for (int j = 0; j < statisDate.size(); j++) {
            Map<String, Object> hashMap = new LinkedHashMap<>(10);
            //这个是依据key进行数据的填充,(根据前面填写的statisKey1进行填充数据)
            hashMap.put("statisKey1", statisData.get(i).getPlatformNickName());
            String statisDateStr = statisDate.get(j);
             //这个是依据key进行数据的填充,(根据前面填写的statisKey2进行填充数据)
            hashMap.put("statisKey2", statisDateStr);
            //参数的验证
            for (String paramKey : statisParamKey) {
              for (BiPlatformStatisRespDTO paramData : statisData.get(i).getStatisData().get(j)) {
                if (paramKey.equals(paramData.getParamKey())) {
                  hashMap.put(paramData.getParamKey(), paramData.getValue() + "(" + paramData.getRateValue() + ")");
                }
              }
            }
            datas.add(hashMap);
          }
        }
        return datas;
      }
    

    excel的导出

    //statisData就是我们查询出来的数据
    public void downloadPlatformIncomeContrast(List<PlatformIncomeRespDTO> statisData, HttpServletResponse response) {
        if (CollectionUtils.isEmpty(statisData)) {
          return;
        }
        //获取参数信息
        final Map<String, PlatformStatisParamRespData> paramInfo = statisData.get(0).getParamInfo();
    
        //拼装列头
        List<ExcelExportEntity> colList = this.dynamicNewAddExcel(paramInfo);
    
        //数据拼装
        List<Map<String, Object>> list = this.dynamicListDataByKey(statisData);
        final String xlsFileName = DateHelper.getNowString(FormatUnit.yyyyMMddHHmmss, true) + ".xls";
        final Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams(), colList, list);
    
        //动态合并纵列[mergeMap key列索引(从0开始),value依赖的列,没有传空,startRow 开始行(从零开始)]
        //Map<Integer, int[]> mer = new HashMap<>();
        //mer.put(0, new int[]{});
        //PoiMergeCellUtil.mergeCells(workbook.getSheetAt(0), mer, 1);
        EasypoiUtil.downLoadExcel(xlsFileName, response, workbook);
      }
    
    • EasypoiUtil工具类
    public static void downLoadExcel(String fileName, HttpServletResponse response, Workbook workbook) {
        try {
          response.setCharacterEncoding("UTF-8");
          response.setHeader("content-Type", "application/vnd.ms-excel");
          response.setHeader("Content-Disposition",
              "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
          workbook.write(response.getOutputStream());
        } catch (IOException e) {
          throw new RuntimeException(e.getMessage());
        }
      }
    
    • PlatformIncomeRespDTO
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class PlatformIncomeRespDTO implements Serializable {
    
      private static final long serialVersionUID = 1100499105160261425L;
    
    
      /**
       * 平台别名
       */
      private String platformNickName;
    
      /*统计时间*/
      private List<String> statisDate;
    
      /*查询参数信息--[用户收入来源统计导出使用]*/
      private Map<String, PlatformStatisParamRespData> paramInfo;
    
    
      /*统计数据*/
      private List<List<BiPlatformStatisRespDTO>> statisData;
    }
    
    • PlatformStatisParamRespData
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class PlatformStatisParamRespData implements Serializable {
    
      private static final long serialVersionUID = 4263523446154995471L;
    
      /**
       * 参数名称
       */
      private String dataName;
    
      /**
       * 参数key
       */
      private String dateKey;
    
      /**
       * 参数描述
       */
      private String dateDesc;
    
    }
    
    • BiPlatformStatisRespDTO
    @Data
    @AllArgsConstructor
    public class BiPlatformStatisRespDTO implements Serializable {
    
      private static final long serialVersionUID = 6070471415344415351L;
    
      @Excel(name = "统计字段", orderNum = "1")
      private String param;
    
      /**
       * 参数的key
       */
      private String paramKey;
    
      /**
       * 参数描述
       */
      private String paramDesc;
    
      private String startDate;
    
      private String endDate;
    
      @Excel(name = "统计数据", orderNum = "2")
      private String value;
    
      private String rateValue;
    
      private Long id;
    
      private Integer riseOrFall;
    
      public BiPlatformStatisRespDTO(String startDate, String paramKey, String value) {
        this.paramKey = paramKey;
        this.startDate = startDate;
        this.value = value;
      }
    
      public BiPlatformStatisRespDTO() {
      }
    }
    

    测试用例

    测试特殊说明

    导出的结果有个控制,是在拼装的时候没有填充此数据,不影响整体效果

    测试结果示例

    在这里插入图片描述

    测试数据json示例

    [
        {
            "paramInfo": {
                "userCount": {
                    "dataName": "用户数", 
                    "dateDesc": "用户信息", 
                    "dateKey": "userCount"
                }, 
                "friendsCount": {
                    "dataName": "好友数", 
                    "dateDesc": "好友信息", 
                    "dateKey": "friendsCount"
                }
            }, 
            "platformNickName": "aaa", 
            "statisData": [
                [
                    {
                        "paramKey": "userCount", 
                        "startDate": "2019-12-26", 
                        "value": "100"
                    }, 
                    {
                        "paramKey": "friendsCount", 
                        "startDate": "2019-12-26", 
                        "value": "200"
                    }
                ], 
                [
                    {
                        "paramKey": "userCount", 
                        "startDate": "2019-12-27", 
                        "value": "300"
                    }, 
                    {
                        "paramKey": "friendsCount", 
                        "startDate": "2019-12-27", 
                        "value": "400"
                    }
                ]
            ], 
            "statisDate": [
                "2019-12-26", 
                "2019-12-27"
            ]
        }, 
        {
            "paramInfo": {
                "userCount": {
                    "dataName": "用户数", 
                    "dateDesc": "用户信息", 
                    "dateKey": "userCount"
                }, 
                "friendsCount": {
                    "dataName": "好友数", 
                    "dateDesc": "好友信息", 
                    "dateKey": "friendsCount"
                }
            }, 
            "platformNickName": "bbb", 
            "statisData": [
                [
                    {
                        "paramKey": "userCount", 
                        "startDate": "2019-12-26", 
                        "value": "500"
                    }, 
                    {
                        "paramKey": "friendsCount", 
                        "startDate": "2019-12-26", 
                        "value": "600"
                    }
                ], 
                [
                    {
                        "paramKey": "userCount", 
                        "startDate": "2019-12-27", 
                        "value": "700"
                    }, 
                    {
                        "paramKey": "friendsCount", 
                        "startDate": "2019-12-27", 
                        "value": "800"
                    }
                ]
            ], 
            "statisDate": [
                "2019-12-26", 
                "2019-12-27"
            ]
        }
    ]
    

    测试用例代码

    public class Simple {
    
      /**
       * @Description: 拼接表头
       * @Param: paramInfo :表头信息
       * @return: java.util.List<cn.afterturn.easypoi.excel.entity.params.ExcelExportEntity>
       * @Author: peikunkun
       * @Date: 2019/12/26 0026 上午 10:42
       */
      private static List<ExcelExportEntity> dynamicNewAddExcel(Map<String, PlatformStatisParamRespData> paramInfo) {
        //表头的集合,用于添加表头
        List<ExcelExportEntity> entityList = new ArrayList<>();
    
        //ExcelExportEntity构造参数【第一个是列名头的统计字段,第二个是需要指定的一个key在填充数据的时候是需要根据这个key进行填充值,第三个参数是列宽】
        ExcelExportEntity platformXh = new ExcelExportEntity("统计字段1", "statisKey1", 30);
        //列的合并(纵向列的同名称会进行合并,效果见上图的平台名称的变化)
        platformXh.setMergeVertical(true);
        entityList.add(platformXh);
    
        ExcelExportEntity statisDateXh = new ExcelExportEntity("统计字段2", "statisKey2", 30);
        entityList.add(statisDateXh);
    
        //参数信息--[用于动态拼接列头]
        final Iterator<String> iterator = paramInfo.keySet().iterator();
        while (iterator.hasNext()) {
          final String paramKeyStr = iterator.next();
          final String paramNameStr = paramInfo.get(paramKeyStr).getDataName();
          //列头由参数汉字名称,参数key为列key
          entityList.add(new ExcelExportEntity(paramNameStr, paramKeyStr, 30));
        }
        return entityList;
      }
    
    
      /**
       * @Description: 拼接数据
       * @Param: statisData :拼接数据
       * @Author: peikunkun
       * @Date: 2019/12/26 0026 上午 10:42
       */
      private static List<Map<String, Object>> dynamicListDataByKey(List<PlatformIncomeRespDTO> statisData) {
        //参数类型
        final Set<String> statisParamKey = statisData.get(0).getParamInfo().keySet();
        final List<String> statisDate = statisData.get(0).getStatisDate();
        final int platformNum = statisData.size();
    
        //最终的数据
        List<Map<String, Object>> datas = new ArrayList<>();
        for (int i = 0; i < platformNum; i++) {
          for (int j = 0; j < statisDate.size(); j++) {
            Map<String, Object> hashMap = new LinkedHashMap<>(10);
            //这个是依据key进行数据的填充,(根据前面填写的statisKey1进行填充数据)
            hashMap.put("statisKey1", statisData.get(i).getPlatformNickName());
            String statisDateStr = statisDate.get(j);
            //这个是依据key进行数据的填充,(根据前面填写的statisKey2进行填充  数据)
            hashMap.put("statisKey2", statisDateStr);
            //参数的验证
            for (String paramKey : statisParamKey) {
              for (BiPlatformStatisRespDTO paramData : statisData.get(i).getStatisData().get(j)) {
                if (paramKey.equals(paramData.getParamKey())) {
                  hashMap.put(paramData.getParamKey(), paramData.getValue() + "(" + paramData.getRateValue() + ")");
                }
              }
            }
            datas.add(hashMap);
          }
        }
        return datas;
      }
    
    
      @Test
      public void Administrator_84_20191226095523() throws IOException {
        System.out.println("欢迎使用单元测试方法【Administrator_84()_20191226095523】");
        System.out.println("此方法测试描述:【】");
        //拼装第一个数据---------------------------------------------------------------------
        final PlatformIncomeRespDTO platformIncomeRespDTO1 = new PlatformIncomeRespDTO();
        platformIncomeRespDTO1.setPlatformNickName("aaa");
        //拼装时间维度
        platformIncomeRespDTO1.setStatisDate(Lists.newArrayList("2019-12-26","2019-12-27"));
        //拼装头信息
        Map<String, PlatformStatisParamRespData> paramInfo1=new HashMap<>();
        paramInfo1.put("userCount", new PlatformStatisParamRespData("用户数","userCount","用户信息"));
        paramInfo1.put("friendsCount", new PlatformStatisParamRespData("好友数","friendsCount","好友信息"));
        platformIncomeRespDTO1.setParamInfo(paramInfo1);
        //拼装数据
        final ArrayList<List<BiPlatformStatisRespDTO>> data1 = Lists.newArrayList();
        data1.add(Lists.newArrayList(new BiPlatformStatisRespDTO("2019-12-26","userCount","100"),new BiPlatformStatisRespDTO("2019-12-26","friendsCount","200")));
        data1.add(Lists.newArrayList(new BiPlatformStatisRespDTO("2019-12-27","userCount","300"),new BiPlatformStatisRespDTO("2019-12-27","friendsCount","400")));
        platformIncomeRespDTO1.setStatisData(data1);
    
    
        //拼装第二个数据---------------------------------------------------------------------
        final PlatformIncomeRespDTO platformIncomeRespDTO2 = new PlatformIncomeRespDTO();
        platformIncomeRespDTO2.setPlatformNickName("bbb");
        //拼装时间维度
        platformIncomeRespDTO2.setStatisDate(Lists.newArrayList("2019-12-26","2019-12-27"));
        //拼装头信息
        Map<String, PlatformStatisParamRespData> paramInfo2=new HashMap<>();
        paramInfo2.put("userCount", new PlatformStatisParamRespData("用户数","userCount","用户信息"));
        paramInfo2.put("friendsCount", new PlatformStatisParamRespData("好友数","friendsCount","好友信息"));
        platformIncomeRespDTO2.setParamInfo(paramInfo2);
    
        //拼装数据
        final ArrayList<List<BiPlatformStatisRespDTO>> data2 = Lists.newArrayList();
        data2.add(Lists.newArrayList(new BiPlatformStatisRespDTO("2019-12-26","userCount","500"),new BiPlatformStatisRespDTO("2019-12-26","friendsCount","600")));
        data2.add(Lists.newArrayList(new BiPlatformStatisRespDTO("2019-12-27","userCount","700"),new BiPlatformStatisRespDTO("2019-12-27","friendsCount","800")));
        platformIncomeRespDTO2.setStatisData(data2);
    
        final ArrayList<PlatformIncomeRespDTO> platformIncomeRespDTOS = Lists.newArrayList(platformIncomeRespDTO1, platformIncomeRespDTO2);
        System.out.println(JSONObject.toJSONString(platformIncomeRespDTOS));
    
        //拼装列头
        List<ExcelExportEntity> colList = dynamicNewAddExcel(paramInfo2);
    
        //数据拼装
        List<Map<String, Object>> list = dynamicListDataByKey(platformIncomeRespDTOS);
    
        //文件名称
        final Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams(), colList, list);
    
        //此功能与【拼装列头】中的 platformXh.setMergeVertical(true);功能效果一样,可直接使用 platformXh.setMergeVertical(true);进行纵向合并
        //动态合并纵列[mergeMap key列索引(从0开始),value依赖的列,没有传空,startRow 开始行(从零开始)]
        //Map<Integer, int[]> mer = new HashMap<>();
        //mer.put(0, new int[]{});
        //PoiMergeCellUtil.mergeCells(workbook.getSheetAt(0), mer, 1);
    
        final FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\1.xls");
        //导出excel
        downLoadExcel(null, fileOutputStream, workbook);
      }
    
    
    
    
      /**
       * @Description: 下载文件
       * @Param: fileName
       * @Param outputStream
       * @Param workbook
       * @return: void
       * @Author: peikunkun
       * @Date: 2019/12/26 0026 上午 10:44
       */
      public static void downLoadExcel(String fileName, FileOutputStream outputStream, Workbook workbook)
          throws IOException {
        try {
          workbook.write(outputStream);
        } catch (IOException e) {
          throw new RuntimeException(e.getMessage());
        } finally {
          outputStream.close();
        }
      }
    }
    
    展开全文
  • excel动态导入导出

    千次阅读 2019-02-20 17:29:21
    这个也是在网上查阅了很多的资料慢慢完善的,需要添加excel样式的可以自己往里面加 excel工具类 import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io....

    这个也是在网上查阅了很多的资料慢慢完善的,需要添加excel样式的可以自己往里面加

    excel工具类

    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.lang.reflect.Field;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.poi.hssf.usermodel.HSSFCellStyle;
    import org.apache.poi.hssf.usermodel.HSSFDateUtil;
    import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    import org.apache.poi.ss.usermodel.Cell;
    import org.apache.poi.ss.usermodel.CellStyle;
    import org.apache.poi.ss.usermodel.Row;
    import org.apache.poi.ss.usermodel.Sheet;
    import org.apache.poi.ss.usermodel.Workbook;
    import org.apache.poi.ss.util.CellRangeAddress;
    import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    
    /**
     * excel工具类
     *
     */
    public class ExcelUtils {
    	
    	
    	/**
    	 * 下载excel文档到客户端
    	 * @param response
    	 * @param hw
    	 */
    	public static void uploadExcel(HttpServletResponse response,HSSFWorkbook hw) {
    		
    		ByteArrayOutputStream fos = null;
    		byte[] retArr = null;
    		
    		try {
    			fos = new ByteArrayOutputStream();
    			hw.write(fos);
    			retArr = fos.toByteArray();
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			
    			try {
    				fos.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    			
    		}
    		
    		OutputStream os = null;
    		
    		try {
    			
    			os = response.getOutputStream();
    			
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		try {
    			response.reset();
    			response.setHeader("Content-Disposition", "attachment; filename="+"excel"+".xls");//要保存的文件名
    			response.setContentType("application/octet-stream; charset=utf-8");
    			try {
    				os.write(retArr);
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    			try {
    				os.flush();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		} finally {
    			
    			if (os != null) {
    				try {
    					os.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    			
    		}
    	}
    
    	
    	/**
         * 生成excel
         * @param data 数据集合
         * @param path 输出路径
         */
        public static HSSFWorkbook createExcel(String sheetName,String sheetTitleName,List<?> data) {
    
            // 创建workbook
            HSSFWorkbook wb = new HSSFWorkbook();
    
            // 创建sheet
            Sheet sheet = wb.createSheet(sheetName);
    
            // 创建表头行
            Row row = sheet.createRow(0);
            Cell oneCell = row.createCell(0);
            oneCell.setCellValue(sheetTitleName);
            
            //合并单元格CellRangeAddress构造参数依次表示起始行,截至行,起始列, 截至列  
            sheet.addMergedRegion(new CellRangeAddress(0,0,0,9));
            
            // 创建单元格样式
            HSSFCellStyle style = wb.createCellStyle();
    
            // 获取实体所有属性
            Field[] fields = data.get(0).getClass().getDeclaredFields();
            
            // 列索引
            int index = 0;
            
            // 列名称
            String name = "";
            
            // 是否日期类型
            boolean isDate = false;
            
            // 转换的日期格式
            String dateFormat = "";
            
            ExcelAnnotation ExcelAnnotation;
            
            // 创建表头
            Row row1 = sheet.createRow(1);
            for (Field f : fields) {
                // 是否是注解
                if (f.isAnnotationPresent(ExcelAnnotation.class)) {
                    // 获取注解
                    ExcelAnnotation = f.getAnnotation(ExcelAnnotation.class);
                    // 获取列索引
                    index = ExcelAnnotation.columnIndex();
                    // 列名称
                    name = ExcelAnnotation.columnName();
                    // 创建单元格
                    creCell(row1, index, name, style);
                }
            }
    
            // 行索引  因为表头已经设置,索引行索引从2开始
            int rowIndex = 2;
            for (Object obj : data) {
                // 创建新行,索引加1,为创建下一行做准备
                row = sheet.createRow(rowIndex++);
                for (Field f : fields) {
                    // 设置属性可访问
                    f.setAccessible(true);
                    // 判断是否是注解
                    if (f.isAnnotationPresent(ExcelAnnotation.class)) {
                        // 获取注解
                        ExcelAnnotation = f.getAnnotation(ExcelAnnotation.class);
                        index = ExcelAnnotation.columnIndex();
                        isDate = ExcelAnnotation.isDate();
                        
                        try {
                        	// 创建单元格     f.get(obj)从obj对象中获取值设置到单元格中
                        	if(isDate) {
                        		dateFormat = ExcelAnnotation.dateFormat();
                        		creCell(row, index, UtilTools.getNewDateFormat((Date) f.get(obj),dateFormat), style);
                        	}else {
                        		creCell(row, index, String.valueOf(f.get(obj)), style);
                        	}
                        } catch (IllegalArgumentException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
    
            return wb;
            
        }
    	
    	
    	/**
         * 生成excel文件直接保存到客户端指定文件夹下
         * @param data 数据集合
         * @param path 输出路径
         */
        public static void createExcelFile(String sheetName,String sheetTitleName,List<?> data, String path) {
        	File file = new File(path);
    
            // 创建workbook
            HSSFWorkbook wb = new HSSFWorkbook();
    
            // 创建sheet
            Sheet sheet = wb.createSheet(sheetName);
    
            // 创建表头行
            Row row = sheet.createRow(0);
            Cell oneCell = row.createCell(0);
            oneCell.setCellValue(sheetTitleName);
            
            //合并单元格CellRangeAddress构造参数依次表示起始行,截至行,起始列, 截至列  
            sheet.addMergedRegion(new CellRangeAddress(0,0,0,9));
            
            // 创建单元格样式
            HSSFCellStyle style = wb.createCellStyle();
    
            // 获取实体所有属性
            Field[] fields = data.get(0).getClass().getDeclaredFields();
            
            // 列索引
            int index = 0;
            
            // 列名称
            String name = "";
            
    		// 是否日期类型
            boolean isDate = false;
            
            // 转换的日期格式
            String dateFormat = "";
    
            ExcelAnnotation ExcelAnnotation;
    
            // 创建表头
            Row row1 = sheet.createRow(1);
            for (Field f : fields) {
                // 是否是注解
                if (f.isAnnotationPresent(ExcelAnnotation.class)) {
                    // 获取注解
                    ExcelAnnotation = f.getAnnotation(ExcelAnnotation.class);
                    // 获取列索引
                    index = ExcelAnnotation.columnIndex();
                    // 列名称
                    name = ExcelAnnotation.columnName();
                    // 创建单元格
                    creCell(row1, index, name, style);
                }
            }
    
            // 行索引  因为表头已经设置,索引行索引从2开始
            int rowIndex = 2;
            for (Object obj : data) {
                // 创建新行,索引加1,为创建下一行做准备
                row = sheet.createRow(rowIndex++);
                for (Field f : fields) {
                    // 设置属性可访问
                    f.setAccessible(true);
                    // 判断是否是注解
                    if (f.isAnnotationPresent(ExcelAnnotation.class)) {
                        // 获取注解
                        ExcelAnnotation = f.getAnnotation(ExcelAnnotation.class);
                      	index = ExcelAnnotation.columnIndex();
                        isDate = ExcelAnnotation.isDate();
                        
                        try {
                        	// 创建单元格     f.get(obj)从obj对象中获取值设置到单元格中
                        	if(isDate) {
                        		dateFormat = ExcelAnnotation.dateFormat();
                        		creCell(row, index, UtilTools.getNewDateFormat((Date) f.get(obj),dateFormat), style);
                        	}else {
                        		creCell(row, index, String.valueOf(f.get(obj)), style);
                        	}
                        } catch (IllegalArgumentException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
    
            FileOutputStream outputStream = null;
            try {
                outputStream = new FileOutputStream(file);
                wb.write(outputStream);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //释放资源
                try {
                    if (outputStream != null) {
                        outputStream.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    
       
    
    
        
        /**
         * 读取excel文件,并把读取到的数据封装到clazz中
         * 
         * @param path
         *            文件路径
         * @param clazz
         *            实体类
         * @return 返回clazz集合
         */
        @SuppressWarnings("resource")
    	public static <T extends Object> List<T> importExcelFile(String path, Class<T> clazz) {
            // 存储excel数据
            List<T> list = new ArrayList<T>();
            FileInputStream is = null;
    
            try {
                is = new FileInputStream(new File(path));
            } catch (FileNotFoundException e1) {
                throw new RuntimeException("文件路径异常");
            }
    
            Workbook wookbook = null;
    
            // 根据excel文件版本获取工作簿
            if (path.endsWith(".xls")) {
                wookbook = xls(is);
            } else if (path.endsWith(".xlsx")) {
                wookbook = xlsx(is);
            } else {
                throw new RuntimeException("文件出错,非excel文件");
            }
    
            // 得到一个工作表
            Sheet sheet = wookbook.getSheetAt(0);
    
            // 获取行总数
            int rows = sheet.getLastRowNum() + 1;
    
            Row row;
    
            // 获取类所有属性
            Field[] fields = clazz.getDeclaredFields();
    
            T obj = null;
            int coumnIndex = 0;
            Cell cell = null;
            ExcelAnnotation ExcelAnnotation = null;
            for (int i = 2; i < rows; i++) {
                // 获取excel行
                row = sheet.getRow(i);
                try {
                    // 创建实体
                    obj = clazz.newInstance();
                    for (Field field : fields) {
                        // 设置属性可访问
                    	field.setAccessible(true);
                        // 判断是否是注解
                        if (field.isAnnotationPresent(ExcelAnnotation.class)) {
                            // 获取注解
                            ExcelAnnotation = field.getAnnotation(ExcelAnnotation.class);
                            // 获取列索引
                            coumnIndex = ExcelAnnotation.columnIndex();
                            // 获取单元格
                            cell = row.getCell(coumnIndex);
                            
                            
                            /*设置cell值开始*/
                            switch (cell.getCellType()) {
                            //数值类型
                            case Cell.CELL_TYPE_NUMERIC:{
                                // Date类型
                                if ( HSSFDateUtil.isCellDateFormatted(cell) ){
                                    Date date = HSSFDateUtil.getJavaDate(cell.getNumericCellValue());
                                    if ( field.getType()==Date.class ) {//Date 类型接收 Date类型
                                        field.set ( obj,date );
                                    }else if ( field.getType()==String.class ) {//String 类型 接收 Date类型
                                        try {
    										field.set ( obj , new SimpleDateFormat("yyyy-MM-dd").parse(cell.getStringCellValue() ) );
    									} catch (IllegalArgumentException e) {
    										e.printStackTrace();
    									} catch (ParseException e) {
    										e.printStackTrace();
    									}
                                    }
                                } else { //纯数值
                                    if ( field.getType()==Integer.class ) {//Integer 类型接收 纯数值
                                        String str = cell.toString();
                                        //去掉 结尾为.0的情况  正常小数 不会去掉有精度意义的小数
                                        if ( str!=null && !"".equals(str.trim()) ) {
                                            String []strs = str.split("\\.");
                                            if ( strs.length > 1 && "0".equals(strs[1]) ) {
                                                str=strs[0];
                                            }
                                        }
                                        field.set(obj, Integer.parseInt(str) ) ;
                                    } else if ( field.getType()==String.class ) { //String 类型接收 纯数值
                                        field.set(obj,  String.valueOf( cell.getNumericCellValue() ) ) ;
                                    }
    
                                }
                                break;
                            }
                            // 字符串类型
                            case Cell.CELL_TYPE_STRING : {
                                if ( field.getType() == Date.class ) { //Data类型接收String
                                    Date date = null;
    								try {
    									date = new SimpleDateFormat("yyyy-MM-dd").parse(cell.getStringCellValue());
    								} catch (ParseException e) {
    									e.printStackTrace();
    								}
                                    field.set(obj,date);
                                } else if ( field.getType()==Integer.class ) { //Integer 类型接收 String
                                    field.set(obj,Integer.parseInt(cell.getStringCellValue()));
                                } else {
                                    field.set(obj,cell.getStringCellValue());
                                }
                                break;
                            }
                            //空值的情况 可以抛异常 也可以 设空值
                            case Cell.CELL_TYPE_BLANK : {
                                field.set(obj,null);
                                break;
                            }
                        }
                        /*设置cell值结束*/   
                            
                        }
                    }
                    // 添加到集合中
                    list.add(obj);
                } catch (InstantiationException e1) {
                    e1.printStackTrace();
                } catch (IllegalAccessException e1) {
                    e1.printStackTrace();
                }
    
            }
    
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return list;
        }
        
        
        
        /**
         * 创建单元格
         * 
         * @param row
         * @param c
         * @param cellValue
         * @param style
         */
        private static void creCell(Row row, int c, String cellValue, CellStyle style) {
            Cell cell = row.createCell(c);
            cell.setCellValue(cellValue);
            cell.setCellStyle(style);
        }
        
    	/**
         * 对日期类型进行格式化
         * 
         * @param d
         * @param fmat
         */
        public static String getNewDateFormat(Date d,String fmat) {
    		String newDate="";
    		if(null!=d) {
    			DateFormat df=new SimpleDateFormat(fmat);
    			newDate=df.format(d);
    		}
    		return newDate;
    	}
        
        /**
         * 对excel 2003处理
         */
        private static Workbook xls(InputStream is) {
            try {
                // 得到工作簿
                return new HSSFWorkbook(is);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 对excel 2007处理
         */
        private static Workbook xlsx(InputStream is) {
            try {
                // 得到工作簿
                return new XSSFWorkbook(is);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    	
    	
    	
    }
    
    
    

    创建自定义注解

    
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    
    /**
     * 定义excel描述注解
     *
     */
    @Retention(RetentionPolicy.RUNTIME)
    public @interface ExcelAnnotation {
    
    	 /**
         * 列索引
         * @return
         */
        public int columnIndex() default 0;
    
        /**
         * 列名
         * @return
         */
        public String columnName() default "";
    
    	/**
         * 是否日期类型
         * @return
         */
        public boolean isDate() default false;
          
        /**
         * 日期字符格式
         * @return
         */
    	public String dateFormat() default "";
    }
    
    

    在需要导出的列上加自定义注解

    public class UserBean {
    	
    	@ExcelAnnotation(columnIndex=0,columnName="序号")
    	private Integer user_id;
    	
    	@ExcelAnnotation(columnIndex=1,columnName="部门id")
    	private Integer dept_id;
    	
    	@ExcelAnnotation(columnIndex=2,columnName="用户名")
    	private String user_account;
    	
    	@ExcelAnnotation(columnIndex=3,columnName="登录密码")
    	private String user_password;
    	@ExcelAnnotation(columnIndex=4,columnName="姓名")
    	private String user_name;
    	
    	@ExcelAnnotation(columnIndex=5,columnName="头像")
    	private String img;
    	
    	@ExcelAnnotation(columnIndex=6,columnName="年龄")
    	private Integer user_age;
    	
    	@ExcelAnnotation(columnIndex=7,columnName="性别")
    	private String user_sex;
    	
    	@ExcelAnnotation(columnIndex=8,columnName="地址")
    	private String user_address;
    	
    	@ExcelAnnotation(columnIndex=9,columnName="生日",isDate=true,dateFormat="yyyy-MM-dd")
    	@DateTimeFormat(pattern="yyyy-MM-dd")
    	private Date user_birth;
    	
    	@ExcelAnnotation(columnIndex=10,columnName="电话")
    	private String user_phone;
    	
    	@ExcelAnnotation(columnIndex=11,columnName="邮箱")
    	private String email;
    	
    	@ExcelAnnotation(columnIndex=12,columnName="最后登录时间",isDate=true,dateFormat="yyyy-MM-dd hh:mm:ss")
    	@DateTimeFormat(pattern="yyyy-MM-dd hh:mm:ss")
    	private Date reg_time;
    	
    	private String dept_name;
    	private String birthStr;
    	private Integer role_id;
    	private String mon;
    	private int num;
    

    导出excel

    public void ExportUserList(HttpServletResponse response) {
    		
    		List<UserBean> userList = userDao.queryUserList();
    		response.setContentType("text/html,charset=utf-8");
    		HSSFWorkbook hw = ExcelUtils.createExcel("用户信息表","用户信息表",userList);
    		//将excel的下载
    		ExcelUtils.uploadExcel(response,hw);
    	    	    
    	}
    

    导入excel

    public Map<String,Object> importExcel(MultipartFile file) {
    		Map<String,Object>map=new HashMap<String, Object>();
    		String filename = file.getOriginalFilename();
    		if(filename.endsWith(".xls") || filename.endsWith(".xlsx")) {
    			String originUrl="D:\\excelTest";
    			
    			// 起个新名称,绝对不能重复 -> UUID : universe unique id
    	        String uuid = UUID.randomUUID().toString();
    	        
    	        // 新名称
    	        String newName = uuid + filename.substring(filename.lastIndexOf("."));
    			String filePath = originUrl + "/" + newName;
    			File f = new File(filePath);
    			try {
    				file.transferTo(f);
    			} catch (IllegalStateException e) {
    				e.printStackTrace();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		    int x=0,y=0,sum=0;
    		    boolean flag=false;
    			List<UserBean> userList = ExcelUtils.importExcelFile(filePath, UserBean.class);
    			f.delete();
    			y=userList.size();
    			for(UserBean u : userList){
    				List<UserBean> user=userDao.getUserByAccount(u.getUser_account());
    				if(user!=null&&user.size()>0){
    					x++;
    				}else{
    					int i=userDao.saveUser(u);
    					sum+=i;
    				}
    			}
    			if(sum==(y-x)){
    				flag=true;
    			}
    			map.put("msg", "共有"+y+"条数据,成功导入"+sum+"条数据,登陆账号重名的数据有"+x+"条");
    			map.put("flag", flag);
    		}else {
    			map.put("msg", "请上传正确格式的excel文档");
    			map.put("flag", false);
    		}
    		return map;
    	}
    
    

    日期问题已解决,欢迎大家在文章底下指出不足的地方

    展开全文
  • 无需安装office,直接引用Microsoft.Office.Interop.Excel.dll文件,导出Excel无需模板,动态定义头以及高亮行显示
  • EasyPoi导出excel动态选择

    千次阅读 2020-06-17 20:17:05
    主要使用easypoi中的ExcelExportEntity类对进行封装,可以设置的属性。 下面直接贴出自己的代码:(注意data数据类型List中的必须为map,不能为实体类,否则会报错) pom文件依赖: <dependency> <...
  • JAVA导出EXCEL实现

    万次阅读 多人点赞 2019-07-31 18:39:28
    JAVA导出EXCEL实现
  • easypoi导出excel嵌套动态列

    千次阅读 2019-08-26 17:31:49
    * @param obj 每一行excel的数据映射,如上第一行为[order:0,sex:sex0.....] **/ public Collection<?> getListCellValue(ExcelExportEntity entity, Object obj) throws Exception { Object value; if (obj ...
  • EasyPoi导出包含动态列Excel

    万次阅读 2018-06-02 16:35:13
    ... <artifactId>easypoi-base <version>3.2.0 @Test public void dynaCol() { try { List<ExcelExportEntity> colList = new ArrayList(); ExcelExportEntity colEntity = new ExcelExportEntity(...导出结果图
  • 而数据导出的格式一般是EXCEL或者PDF,我这里就用两篇文章分别给大家介绍下。(注意,我们这里说的数据导出可不是数据库中的数据导出!么误会啦^_^) 呵呵,首先我们来导出EXCEL格式的文件吧。现在主流的操作Ex...
  • 导入功能:基于poi导入做了一层封装、支持注解方式标识属性对应Excel列、并支持简单规则校验、具体规则校验可以根据自己需求自定义 两种导出功能:一种基于poi的导出,一种基于jxls模板导出
  • java中Excel导出模板(跨行跨列导出) 笔者昨天有个需求,就是把下面的课时信息页签的内容原样导出: 这个地方看似不难,实际后台很复杂,数据的来源也复杂,并不好处理。但是这不是让我纠结的地方。 我纠结的...
  • 分享POI导出excel(含表头,冰冻,动态列动态数据) 首先导入 POI : <!-- excel --> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId>...
  • 润乾报表页面超过255列导出excel

    千次阅读 2016-11-29 17:56:51
    直接在页面上点击导出excel的按钮,就会弹出对话框提示excel不支持超过255,也就无法正常导出,所以要想导出这样的报表就必须采取一些特殊的设置,下面就做一个简单的例子,实现超过255的不分页报表导出excel。...
  • easyui 导出excel导出隐藏

    千次阅读 2020-03-04 09:33:53
    easyui 的 datagrid-export.js 来导出excel,使用起来非常简单 官方文档 http://www.jeasyui.net/extension/204.html 但是导出的时候会把隐藏的也会导出来 解决方案:
  • java配置文件动态配置excel导出动态数据并发送email 可以动态配置excel名称 数 列宽 列名 sheet名称 sheet个数
  • 具体思路是:后端返回给我json数据,前端根据数据和具体的几项字段去导出excel表格,还有导出多个sheet,多页表格到一个excel表里面,具体思路 根据Export2Excel插件,并修改插件Export2Excel完成导出多页(多个sheet...
  • 【需求】:当datagrid表格显示的每的字段名称并不固定,如要求每字段为日期,这样的话,我们不能从新定义实体来接收这个字段,因为不同的条件,后台返回的数据的时间也不会固定,而这时用常用的导出Excel的工具...
  • 提到Excel导出功能,可能很多人都使用springmvc框架做过,笔者今天要给大家分享的是基于springBoot开发Excel复杂模板导出功能(所谓复杂模板指在模板里的特定表头里有不同的单元格合并以及背景色,字体颜色的填充,...
  • Kendo Grid 部分列导出excel

    千次阅读 2018-08-01 15:21:08
    导出excel时,不需要导出所有,部分导出excel bizNo不导出excel //点击 &amp;lt;button class=&quot;widthnotcertainbutton&quot; data-bind=&quot;events: {click:ExportVoucher}&...
  • table2excel指定不导出某些

    千次阅读 2018-02-27 23:07:23
    有时候用table2excel导出excel的时候,希望不导出某一些,除了可以用指定不导出类名之外,还可以这样 function ExportExcel(DivName, fileName, cols) { $("" + DivName).table2excel({ exclude: &...
  • 导出动态Excel表头、动态跨行、跨

    千次阅读 2017-12-29 18:47:08
    // 设置excel宽度 sheet.setColumnWidth(0, 5000); sheet.setColumnWidth(1, 3500); int colCount = joHeads3.length + 5; ArrayList<String> headers = new ArrayList(); headers.add( "教师...
  • C#-WinForm(2种dataGridView导出Excel)批量导出,高效率,36万行,15秒
  • Java实现Excel多表头动态数据导出

    千次阅读 2020-07-23 13:05:12
    好久没时间写帖子了,由于工作需要,写一个基于JAVA实现的Excel多表头动态导出功能,首先可能这个叫法比较啰嗦,下面我们先看看什么是Excel多表头动态导出(效果图): 它包含两部分:1、是表头,就像大家看到的...
  • 上图看效果 导出加上不同图片 1.导包 &lt;dependency&gt; &lt;groupId&gt;org.apache.poi&lt;/groupId&gt; &lt;artifactId&gt;poi&lt;/artifactId&gt; ...
  • 1:引入相关js文件2:页面布局 带noExlclass的行不会被输出到excel中 带noExlclass的行不会被输出到excel中 这一行会被导出excel
  • EasyExcel 动态导出指定

    万次阅读 2021-07-21 15:32:15
    指定列动态导出导出的基础上,添加导出字段,可实现动态导出数据 根据官方文档,有两种导出方式,一种需要手动关闭文件流,一种自动关闭文件流,在此我选择自动关闭文件流的方式。 ExcelWriterBuild
  • c#导出导入excel 自定义字段 自定义 OleDb方式的excel导入 可以实现自定义字段,不按照模版的方式导出

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,737
精华内容 21,094
关键字:

excel动态列导出