POI之HSSF,XSSF,SXSSF,PDF循环写入分页

最新推荐文章于 2024-05-04 21:21:00 发布
置顶 最新推荐文章于 2024-05-04 21:21:00 发布
阅读量1.1k 收藏
点赞数
分类专栏： Excel导出导入 文章标签： java poi excel pdf循环写入 SXSSF工具类使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T_james/article/details/109627627
版权

针对POI3.9jar包中的相关工具类HSSF,XSSF,SXSSF的理解，以及PDF实现循环写入及分页的实现

    需求如下：

          根据接口传递的相关数据，导出一定样式（合并行列，上色，加粗，循环写入）的表格，行数视数据量多少而定

    原有结构：

          假定100个人 100份数据分100个excel导出，采用HSSFWorkbook类导出

     

接下来逐步由此产生问题进而解决：

  1. 改造原有写入逻辑，传入HSSFWorkbook参数在循环外层一直持有，不断获取最新一行然后追加----结果：报行数65535的错且写入后期超级慢（不可取） 
    private void generateUserArchive(List<RangeRetVo> selfInfo,
                                     List<RangeRetVo> platformInfo, List<RangeRetVo> courseInfo,
                                     Map<Long, List<TargetSetting>> sortedMap, FilterCondition filter,
                                     List<TargetEntity> targetEns, List<TargetDetailEntity> dTargetEns, String baseDir,
                                     Long timestamp, List<UserCustomPropertyEntity> customPropertyList) {

        //为每一个用户生成一个文档
        for (RangeRetVo self : selfInfo) {
            HSSFWorkbook wb = new HSSFWorkbook();
            HSSFSheet sheet = wb.createSheet("111");
            //根据param中选择的总指标和统计周期类型设计表头
            HSSFFont bold = wb.createFont();
            bold.setFontName("仿宋_GB2312");
            bold.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);//粗体显示
            bold.setFontHeightInPoints((short) 12);  //字体大小

            HSSFCellStyle centerHeadStyle = wb.createCellStyle();
            centerHeadStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);  //表头居中
            centerHeadStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
            centerHeadStyle.setFont(bold);
            centerHeadStyle.setFillForegroundColor(IndexedColors.LIGHT_CORNFLOWER_BLUE.getIndex());
            centerHeadStyle.setFillPattern(CellStyle.SOLID_FOREGROUND);

            HSSFCellStyle leftHeadStyle = wb.createCellStyle();
            centerHeadStyle.setAlignment(HSSFCellStyle.ALIGN_LEFT);  //表头居中
            centerHeadStyle.setFont(bold);

            HSSFCellStyle centerStyle = wb.createCellStyle();
            centerStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);  //居中

            HSSFCellStyle leftStyle = wb.createCellStyle();
            leftStyle.setAlignment(HSSFCellStyle.ALIGN_LEFT);  //左端

            HSSFCellStyle rightStyle = wb.createCellStyle();
            rightStyle.setAlignment(HSSFCellStyle.ALIGN_RIGHT);  //左端

            HSSFRow row = sheet.createRow(0);
            HSSFCell cell = row.createCell(0);
            cell.setCellValue("时间范围：" + filter.getStartTime() + "~" + filter.getEndTime());
            cell.setCellStyle(centerHeadStyle);
            sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 8));

            int headCellOffset = 0;

            //表格数据起始行
            int rowCount = 5;

            //表头数据起始行
            int headRowOffset = 1;
            row = sheet.createRow(headRowOffset);
            cell = row.createCell(headCellOffset);
            cell.setCellValue("个人信息");
            cell.setCellStyle(centerHeadStyle);
            headCellOffset++;

            cell = row.createCell(headCellOffset);
            cell.setCellValue("姓名");
            cell.setCellStyle(rightStyle);

            cell = row.createCell(headCellOffset + 1);
            cell.setCellValue(self.getUserName());
            cell.setCellStyle(leftStyle);

            headRowOffset++;
            headRowOffset = headRowOffset % 5 == 0 ? 1 : headRowOffset % 5;
            headCellOffset = headRowOffset % 5 == 0 ? headCellOffset + 2 : headCellOffset;

            row = sheet.createRow(headRowOffset);
            cell = row.createCell(headCellOffset);
            cell.setCellValue("账号");
            cell.setCellStyle(rightStyle);

            cell = row.createCell(headCellOffset + 1);
            cell.setCellValue(self.getLoginName());
            cell.setCellStyle(leftStyle);

            headRowOffset++;
            headRowOffset = headRowOffset % 5 == 0 ? 1 : headRowOffset % 5;
            headCellOffset = headRowOffset % 5 == 0 ? headCellOffset + 2 : headCellOffset;

            //List<TargetSetting> selfSetting = sortedMap.get(ReportConts.SELF_RANGE);
            for (TargetResult res : self.getTargetResults()) {
                if (res.getTypeName().startsWith(ReportConts.CUSTOM_TARGET_PERFIX)) {
                    //自定义信息
                    Long customId = Long.parseLong(res.getTypeName().split("_")[1]);
                    Optional<UserCustomPropertyEntity> op = customPropertyList.stream()
                            .filter(e -> e.getId().equals(customId)).findFirst();
                    if (op != null && op.isPresent()) {
                        UserCustomPropertyEntity en = op.get();
                        row = sheet.getRow(headRowOffset);
                        if (row == null) {
                            row = sheet.createRow(headRowOffset);
                        }
                        cell = row.createCell(headCellOffset);
                        cell.setCellValue(en.getName());
                        cell.setCellStyle(rightStyle);

                        cell = row.createCell(headCellOffset + 1);
                        cell.setCellValue(res.getTargetVal() + "");
                        cell.setCellStyle(leftStyle);

                        headRowOffset++;
                        headRowOffset = headRowOffset % 5 == 0 ? 1 : headRowOffset % 5;
                        headCellOffset = headRowOffset == 1 ? headCellOffset + 2 : headCellOffset;
                    }
                } else {
                    Optional<TargetEntity> tEn = targetEns.stream()
                            .filter(e -> e.getTypeName().equals(res.getTypeName())).findFirst();
                    if (tEn.isPresent()) {
                        TargetEntity t = tEn.get();
                        row = sheet.getRow(headRowOffset);
                        if (row == null) {
                            row = sheet.createRow(headRowOffset);
                        }
                        cell = row.createCell(headCellOffset);
                        cell.setCellValue(t.getName());
                        cell.setCellStyle(rightStyle);

                        cell = row.createCell(headCellOffset + 1);
                        cell.setCellValue(res.getTargetVal() + "");
                        cell.setCellStyle(leftStyle);

                        headRowOffset++;
                        headRowOffset = headRowOffset % 5 == 0 ? 1 : headRowOffset % 5;
                        headCellOffset = headRowOffset == 1 ? headCellOffset + 2 : headCellOffset;
                    }
                }

            }
            //合并个人信息
            sheet.addMergedRegion(new CellRangeAddress(1, 4, 0, 0));

            //处理平台信息
            Optional<RangeRetVo> platformOp = platformInfo.stream()
                    .filter(e -> self.getUserId().equals(e.getUserId())).findFirst();

            if (platformOp.isPresent()) {
                headRowOffset = 1;
                headCellOffset = sheet.getRow(headRowOffset).getLastCellNum();
                RangeRetVo vo = platformOp.get();
                List<TargetSetting> platformSetting = sortedMap.get(ReportConts.PLATFORM_RANGE);
                row = sheet.getRow(headRowOffset);
                if (row == null) {
                    row = sheet.createRow(headRowOffset);
                }
                cell = row.createCell(headCellOffset);
                cell.setCellValue("平台数据");
                cell.setCellStyle(centerHeadStyle);
                sheet.addMergedRegion(new CellRangeAddress(1, 4, headCellOffset, headCellOffset));
                headCellOffset++;

                List<Map<String, Object>> platformDetails = new ArrayList<>();
                for (TargetResult res : vo.getTargetResults()) {
                    Optional<TargetEntity> tEn = targetEns.stream()
                            .filter(e -> e.getTypeName().equals(res.getTypeName())).findFirst();
                    if (tEn.isPresent()) {
                        row = sheet.getRow(headRowOffset);
                        if (row == null) {
                            row = sheet.createRow(headRowOffset);
                        }
                        TargetEntity t = tEn.get();
                        cell = row.createCell(headCellOffset);
                        cell.setCellValue(t.getName());
                        cell.setCellStyle(rightStyle);

                        cell = row.createCell(headCellOffset + 1);
                        cell.setCellValue(res.getTargetVal() + "");
                        cell.setCellStyle(leftStyle);

                        headRowOffset++;
                        headRowOffset = headRowOffset % 5 == 0 ? 1 : headRowOffset % 5;
                        headCellOffset = headRowOffset == 1 ? headCellOffset + 2 : headCellOffset;

                        if (!res.getDetails().isEmpty()) {
                            platformDetails.addAll(res.getDetails());
                        }

                    }
                }

                //处理平台数据详情
                if (!platformDetails.isEmpty()) {
                    List<TargetDetailSetting> dTypeNames = new ArrayList<>();
                    for (TargetSetting tSetting : platformSetting) {
                        for (TargetDetailSetting dtSetting : tSetting.getDetailSettings()) {
                            Optional<TargetDetailSetting> op = dTypeNames.stream()
                                    .filter(e -> dtSetting.getDTypeName().equals(e.getDTypeName()))
                                    .findFirst();
                            if (!op.isPresent()) {
                                dTypeNames.add(dtSetting);
                            }
                        }
                    }

                    List<TargetDetailSetting> sortDTypeNames = dTypeNames.stream()
                            .sorted((o1, o2) -> {
                                if (o1.getDTargetOrder() >= o2.getDTargetOrder()) {
                                    return 1;
                                }
                                return 0;
                            }).collect(Collectors.toList());

                    HSSFSheet loginSheet = wb.createSheet("222");
                    HSSFRow loginRow = null;
                    HSSFCell loginCell = null;

                    int loginRowCount = 0;

                    loginRow = loginSheet.createRow(loginRowCount);
                    for (int i = 0; i < sortDTypeNames.size(); i++) {
                        TargetDetailSetting dtSetting = sortDTypeNames.get(i);
                        TargetDetailEntity dtEn = dTargetEns.stream()
                                .filter(e -> dtSetting.getDTypeName().equals(e.getdTypeName()))
                                .findFirst().get();
                        loginCell = loginRow.createCell(i);
                        loginCell.setCellValue(dtEn.getdName());
                        loginCell.setCellStyle(centerHeadStyle);
                    }
                    loginRowCount++;

                    for (Map<String, Object> map : platformDetails) {
                        loginRow = loginSheet.createRow(loginRowCount);
                        for (int i = 0; i < sortDTypeNames.size(); i++) {
                            TargetDetailSetting dtSetting = sortDTypeNames.get(i);
                            String colName = dtSetting.getDTypeName();
                            loginCell = loginRow.createCell(i);
                            loginCell.setCellValue(map.get(colName) + "");
                            loginCell.setCellStyle(centerStyle);
                        }
                        loginRowCount++;
                    }
                }

            }

            //处理课程信息
            Optional<RangeRetVo> courseOp = courseInfo.stream()
                    .filter(e -> self.getUserId().equals(e.getUserId())).findFirst();
            if (courseOp.isPresent()) {
                headRowOffset = 1;
                headCellOffset = sheet.getRow(headRowOffset).getLastCellNum();
                RangeRetVo vo = courseOp.get();
                List<TargetSetting> courseSetting = sortedMap.get(ReportConts.COURSE_RANGE);
                row = sheet.getRow(headRowOffset);
                if (row == null) {
                    row = sheet.createRow(headRowOffset);
                }
                cell = row.createCell(headCellOffset);
                cell.setCellValue("333");
                cell.setCellStyle(centerHeadStyle);
                sheet.addMergedRegion(new CellRangeAddress(1, 4, headCellOffset, headCellOffset));
                headCellOffset++;

                List<Map<String, Object>> courseDetails = new ArrayList<>();
                for (TargetResult res : vo.getTargetResults()) {
                    Optional<TargetEntity> tEn = targetEns.stream()
                            .filter(e -> e.getTypeName().equals(res.getTypeName())).findFirst();
                    if (tEn.isPresent()) {
                        TargetEntity t = tEn.get();
                        row = sheet.getRow(headRowOffset);
                        if (row == null) {
                            row = sheet.createRow(headRowOffset);
                        }
                        cell = row.createCell(headCellOffset);
                        cell.setCellValue(t.getName());
                        cell.setCellStyle(rightStyle);

                        cell = row.createCell(headCellOffset + 1);
                        if (reportProcessorFactory.isDuration(res.getTypeName())) {
                            Long d = Long.parseLong(res.getTargetVal() + "");
                            String val = ReportProcessorFactory.durationFormat(d);

                            //时间转换，换成   时:分:秒(0.0分钟/0.0课时)
                            double minute = 0.0;
                            double courseHour = 0.0;
                            try {
                                minute = BigDecimalUtil.divFloor(String.valueOf(d),"60",1);
                                courseHour = BigDecimalUtil.divFloor(minute,45.0,1);
                            } catch (IllegalAccessException e) {
                                e.printStackTrace();
                            }
                            val = val +"(" + minute + "分钟/"+ courseHour + "课时" +")";

                            cell.setCellValue(val);
                        } else {
                            cell.setCellValue(res.getTargetVal() + "");
                        }
                        cell.setCellStyle(leftStyle);

                        headRowOffset++;
                        headRowOffset = headRowOffset % 5 == 0 ? 1 : headRowOffset % 5;
                        headCellOffset = headRowOffset == 1 ? headCellOffset + 2 : headCellOffset;

                        if (!res.getDetails().isEmpty()) {
                            courseDetails.addAll(res.getDetails());
                        }

                    }
                }

                if (courseDetails.size() > 0) {
                    //根据courseId去重
                    courseDetails = courseDetails.stream()
                            .collect(Collectors.collectingAndThen(Collectors.toCollection(
                                    // 利用 TreeSet 的排序去重构造函数来达到去重元素的目的
                                    () -> new TreeSet<>(
                                            Comparator.comparing(e -> e.get("COURSE_ID").toString()))),
                                    ArrayList::new));

                    List<TargetDetailSetting> dTypeNames = new ArrayList<>();
                    for (TargetSetting tSetting : courseSetting) {
                        for (TargetDetailSetting dtSetting : tSetting.getDetailSettings()) {
                            Optional<TargetDetailSetting> op = dTypeNames.stream()
                                    .filter(e -> dtSetting.getDTypeName().equals(e.getDTypeName()))
                                    .findFirst();
                            if (!op.isPresent()) {
                                dTypeNames.add(dtSetting);
                            }
                        }
                    }

                    List<TargetDetailSetting> sortDTypeNames = dTypeNames.stream()
                            .sorted((o1, o2) -> {
                                if (o1.getDTargetOrder() >= o2.getDTargetOrder()) {
                                    return 1;
                                }
                                return 0;
                            }).collect(Collectors.toList());

                    row = sheet.createRow(rowCount);
                    cell = row.createCell(0);
                    cell.setCellValue("课程名称");
                    cell.setCellStyle(centerHeadStyle);
                    for (int i = 0; i < sortDTypeNames.size(); i++) {
                        TargetDetailSetting dtSetting = sortDTypeNames.get(i);
                        TargetDetailEntity dtEn = dTargetEns.stream()
                                .filter(e -> dtSetting.getDTypeName().equals(e.getdTypeName()))
                                .findFirst().get();
                        cell = row.createCell(i + 1);
                        cell.setCellValue(dtEn.getdName());
                        cell.setCellStyle(centerHeadStyle);
                    }
                    rowCount++;

                    //根据类别分组
                    Map<Integer, List<Map<String, Object>>> categoryDetail = courseDetails.stream()
                            .collect(
                                    Collectors.groupingBy(e -> (int) e.get(ReportConts.CATEGORY_TYPE)));

                    //根据类别依次展示
                    for (Entry<Integer, List<Map<String, Object>>> en : categoryDetail.entrySet()) {
                        int categoryType = en.getKey();
                        List<Map<String, Object>> typeDetail = en.getValue();
                        if (categoryType == ReportConts.CATEGORY_BASE) {
                            row = sheet.createRow(rowCount);
                            cell = row.createCell(0);
                            cell.setCellValue("444");
                            cell.setCellStyle(centerHeadStyle);
                            rowCount++;
                        } else if (categoryType == ReportConts.CATEGORY_PROFESSION) {
                            row = sheet.createRow(rowCount);
                            cell = row.createCell(0);
                            cell.setCellValue("555");
                            cell.setCellStyle(centerHeadStyle);
                            rowCount++;
                        } else if (categoryType == ReportConts.CATEGORY_PRACTICE) {
                            row = sheet.createRow(rowCount);
                            cell = row.createCell(0);
                            cell.setCellValue("666");
                            cell.setCellStyle(centerHeadStyle);
                            rowCount++;
                        }

                        for (Map<String, Object> map : typeDetail) {
                            row = sheet.createRow(rowCount);
                            cell = row.createCell(0);
                            cell.setCellValue(map.get("COURSE_NAME") + "");
                            cell.setCellStyle(centerStyle);
                            for (int i = 0; i < sortDTypeNames.size(); i++) {
                                TargetDetailSetting dtSetting = sortDTypeNames.get(i);
                                String colName = dtSetting.getDTypeName();
                                cell = row.createCell(i + 1);
                                if (colName.equals(ReportConts.D_LEARN_DURATION) || colName
                                        .equals(ReportConts.D_COURSE_DURATION)) {
                                    Long d = Long.parseLong(map.get(colName) + "");
                                    String val = ReportProcessorFactory.durationFormat(d);
                                    cell.setCellValue(val);
                                } else {
                                    cell.setCellValue(map.get(colName) + "");
                                }
                                cell.setCellStyle(centerStyle);
                            }
                            rowCount++;
                        }
                    }
                }
            }
            File file = new File(baseDir,
                    filter.getReportId() + "-u-" + self.getUserName() + "-" + self.getUserId() + "-"
                            + +timestamp + ".xls");
            try (FileOutputStream out = new FileOutputStream(file)) {
                out.flush();
                wb.write(out);
            } catch (IOException e) {
                e.printStackTrace();
            }    
        }

     

  2. 改造后逻辑不变，采用XSSFWorkbook工具类，基于其比HSSFWorkbook可执行行数更多的优势进行写入，虽然慢但是突破了65535行数限制----结果：上线后该功能直接在大数据量情况下假死（4w行+），且后期依旧很慢，导出接近40分钟 
    if(null==xssfWorkbook) {
            xssfWorkbook = new XSSFWorkbook();
            sheet = xssfWorkbook.createSheet("111");

        }else{
            sheet = sxssfWorkbook.getSheet("111");
            createRows = sheet.getLastRowNum()+1;
            rowCount = sheet.getLastRowNum()+1;
        }

     

  3. 发现上述两种方法的问题：1.上诉两种方法是查询大批量的数据写入一个临时的集合（数据量大集合也大），长期持有因为写入表格比较慢导致不释放。2.HSSFWorkbook和XSSFWorkbook都是占用当前的写入内存，两者结合导致内存爆满直接挂掉

     解决办法：

         1.采用SXSSFWorkbook工具类，优点之一在于可以设置将写入文件临时写入本地磁盘减少内存占用率，且可以对临时文件进行压缩保持大小

//设置可读文件的大小为300行数据 其余全部写入临时磁盘保存不占用内存
SXSSFWorkbook sxssfWorkbook = new SXSSFWorkbook(300);
//设置是否可压缩--此处会影响导出效率
sxssfWorkbook.setCompressTempFiles(true);

         2.本地调试后减少每次查询数据规模，多批次写入减少临时集合大小及时释放---原有为200组，现优化为50组上下

         3.经沟通后，减少合并行列的操作，进行常规的数据逐行写入的方式

         4.优化结果：导出excel在4w+行速度在3-10分钟  应该还有压测空间，希望小伙伴有好的建议哦。。

 

 

PDF循环写入分页--后续相关需求直接在此上更新

//1.在外层声明一个document进行不断写入和接收
Document document = null;

//2.写入初始数据和表头后将document保持开启状态
documentDetail = new Document();
PdfArchiveUtil.setDocumentPageSize(documentDetail, sortedMap, true);
PdfWriter pdfWriterDetail = PdfWriter.getInstance(documentDetail, new FileOutputStream(f));
documentDetail.open();// 打开文档

//3.用声明的document进行循环写入接收，内层是一个一个的PdfPTable写入document内
PdfPTable selfTable = new PdfPTable(7);
PdfPCell cell = new PdfPCell();
selfTable.addCell(c);

//4.关于分页--不管老数据的显示问题情况下直接开新的一页进行写入
document.newPage();

//5.空行问题--只有设置了行间距后Chunk.NEWLINE才会生效
PdfWriter  writer = PdfWriter.getInstance(document, new FileOutputStream(f));
//设置行间距
writer.setInitialLeading(10);
document.add(Chunk.NEWLINE);
document.add(Chunk.NEWLINE);

//6.写入效率问题--大概2000+页以上的数据写入10分钟。不知道慢不慢哈哈

突然发现还是一些场景和大数量的情况下还是得多考虑，还是得继续学习！！！

      

     

准时长大
关注
专栏目录
Java通过POI实现将数据写入到Excel表格
m0_56243930的博客
03-07 5942
Java通过POI实现将数据写入到Excel表格
POI导出excel的几种方式及HSSFWorkbook的代码实现
qq_33891573的博客
10-30 1619
由于时间问题,文中代码没有进行细致的分析讲解  POI是Apache软件基金会的开放源码函式库是Apache下的顶级项目,提供API给Java程序对Microsoft Office格式档案读和写的功能。即通过简单的代码和后端流程即可实现指定数据导出Excel格式文件,便于企业进行数据分析备份等.  POI导出Excel最常用的是第一种方式HSSFWorkbook，不过这种方式数据量大的话会产生报错...
使用POI循环写入数据时发现只有最后一列有数据
桃子dev的博客
06-20 1942
直接说重点： 　　一般出现在多重（一般是两重）循环，再多几重效率就很低了。 　　检查调用createRow() 是否在外层循环调用的，如果是在内层循环调用就会出现这个问题，因为程序会不停的重新创建行，直至最后一个cell中的数据写入，跳至下一行同上，所以会出现只有最后一列数据的情况。 ...
POI分多次向生成的EXCEL中写入数据
花&败
11-22 7569
一：分多次将数据写入EXCEL   1：这种方式效率比较低，数据量越大越明显，4万条数据要2分钟左右 package com.test; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException;...
POI实现数据分页读取写入excel
qq_36043775的博客
05-18 1420
excel工具类如下： 基本分四部走， 第一步：初始构建SXSSF对象及其样式、字体 第二步：构建标题行 第三步：写入数据 第四步：将数据写入excel public class SXSSFExcel { private static Logger log = LoggerFactory.getLogger(HssfExcelTool.class); private SXSSFWorkbook workbook;// 工作薄 private SXSSFSheet sheet;//
java poi分批次导入Excel
09-12 503
最近换了新工作，公司要求导入Excel要分批次导入，并且是多线程的情况下执行导入，查了很多资料，没看到比较复合的，就打算自己写一个吧，可能有不足，希望指出。 上面说到多线程，这边就不贴出代码了，具体思路就是一个导入开辟一个线程，下面主要写一下我的分批次的代码思路： 分批次导入-方法一 先介绍我一开始的写法： 通过一个（最大行数/设置读取的行数）的 余数向上取整 来控制循环次数。 ...
java Excel数据导出，HSSH、 XSSF、SXSSF、EasyExcel实现
11-12
首先，Apache POI提供了三种主要的接口来操作Excel文件：HSSF（Horrible Spreadsheet Format）用于处理老版本的.xls文件，XSSF（XML Spreadsheet Format）用于处理.xlsx文件，而SXSSF（Streaming Usermodel API）则...
java的POI操作Excel文件.pdf
11-11
POI库支持多种Excel版本（如HSSF for .xls和XSSF for .xlsx）。不同版本之间可能存在细微差异，因此在编写代码时要考虑到这些兼容性问题。同时，捕获并处理可能出现的异常，如IOException和NullPointerException，...
POI技术将excel解析导入mysql.pdf
06-27
尤其是对于Excel文档，POI提供了两种主要的Excel文件格式支持，一种是基于HSSF的对.xls格式（Excel 97-2003）的支持，另一种是基于XSSF的对.xlsx格式（Excel 2007+）的支持。在本例中，由于文档标题指出是解析2003-...
List<Map>写入Excel，poi操作
李文_广的博客
06-21 5407
List<Map>导出Excel。 poi操作 poi3.8 java操作Excel2007
导出百万数据优化 分批写入_POI如何高效导出百万级Excel数据？
weixin_39630999的博客
01-24 800
在一个具有统计功能的系统中，导出excel功能几乎是一定的，如何导出excel？导出的数据有多少？如何高效的导出？Excel简介什么是excel就不用介绍了，这里主要说明不同版本下每个sheet下的行列限制。版本区间行数列数文件后缀Excel 2003及以下65535256xlsExcel 2007及以上104857616384xlsx由上面可知 Excel 2003及以下是无法实现单s...
HP-JavaUtil: xls 操作类
weixin_34384681的博客
04-28 94
Content ExportExcelAndSave( String[] header, List<Object> excelList, String sheetTitle, String filePath, String fileName) @param header 表格属性列...
excel poi 文件导出，支持多sheet、多列自动合并。
weixin_30821731的博客
06-29 443
参考博客： 　　http://www.oschina.net/code/snippet_565430_15074 　　增加了多sheet，多列的自动合并。 　　修改了部分过时方法和导出逻辑。 　　优化了标题，导出信息等 先看下效果，如果正常导出是这样子： 　　 自动合并后是： 　　 动态图示例： 　　 poi导出并不是一件很麻烦的事情，只是逻辑相对复杂，要考虑到各种...
HSSFWorkbook 锁定部分单元格，或者锁定一个单元格
一窍不通只会复制粘贴的Java工程师
04-17 4215
最近的项目中用到了poi方式创建excel文件， 某些单元格要进行锁定，某些单元格需要进行填写选项的预设值， 发现有两种需求 1、锁定大部分的单元格 2、只锁定某一个单元格 就以上两种情况，有不同的解决办法  需求1：锁定大部分的单元格 1.1创建单元格 及其sheet HSSFWorkbook workbook = new HSSFWorkbook();
JAVA-POI && easyEXCEL
一个搬砖工人
08-07 1380
save read excel
poi操作word实现分页
johnhuster的专栏
03-16 8158
需求场景： 1、在word模板基础上多次创建一个表格模板 2、该表格模板不能沾满一页，及时能占满拷贝时也存在一些问题，表格模板如下所示 先使用 XWPFDocument.createTable(); // 创建一个空表格 XWPFDocument.setTable(document.getTables().size() - 1, originTable); //originT...
关于POI设置打印区域 动态添加打印区域问题
csdn853700321的博客
07-24 3143
POI 动态设置打印区域只需要设置一次固定的打印区域设置不连续或者不固定的打印区域 下面是自己在使用poi导出Excel并设置打印区域问题的小结 只需要设置一次固定的打印区域 假如只需要设置一次打印区域即可完成业务需求则使用以下方法即可 //sheetIndex–从0开始的sheet的索引编号 //startColumn-打印区域的开始列号 // endColumn- 打印区域的结束列号 ...
POI学习笔记（一）
小宝
06-29 358
项目中经常要解析和生成Excel文件，最常用的开源组件有poi与jxl。jxl是韩国人开发的，发行较早，但是更新的很慢，目前似乎还不支持excel2007。poi是apache下的一个子项目，poi应该是处理ms的office系列文档最好的组件了。poi3.6版本已经开始支持excel2007了。但是由于excel2007底层的实现似乎变成xml与excel2003底层存储发生了本质的变化，因此p...
最新性能爆炸！SXSSFWorkbook原文件上追加写入&amp；分页导出
最新发布
2401_84166497的博客
05-04 218
/ 这里业务对象有对应属性，且属性名与columnNam匹配。// 确保工作簿以指定模式打开。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值