使用Apache POI导出Excel小结

关于使用Apache POI导出Excel我大概会分三篇文章去写

导出XLS格式文档

做企业应用项目难免会有数据导出到Excel的需求，最近在使用其，并对导出Excel封装成工具类开放出来供大家参考。关于Apache POI Excel基本的概念与操作我在这里就不啰嗦了。

请大家参考如下：

在使用Apache POI导出Excel有以下限制:

  • Excel <=2003 数据限制，行(65536)*列(256)
  • Excel =2007 数据限制，行(1048576)*列(16384)

POI结构说明

包名称 说明

HSSF提供读写Microsoft Excel XLS格式档案的功能。

XSSF提供读写Microsoft Excel OOXML XLSX格式档案的功能。

SXSSF提供基于流式读写Microsoft Excel OOXML XLSX格式档案的功能(适用于大数据量)。

POI常用类说明

以HSSF为例其他的只是前缀命名变动

  • 如HSSF-->HSSFWorkbook、XSSF-->XSSFWorkbook、SXSSF-->SXSSFWorkbook

类名 说明

HSSFWorkbook Excel的文档对象

HSSFSheet Excel的表单

HSSFRow Excel的行

HSSFCell Excel的格子单元

HSSFFont Excel字体

HSSFDataFormat 格子单元的日期格式

HSSFHeader Excel文档Sheet的页眉

HSSFFooter Excel文档Sheet的页脚

HSSFCellStyle 格子单元样式

HSSFDateUtil 日期

HSSFPrintSetup 打印

HSSFErrorConstants 错误信息表

下来给大家依次展现代码:

Maven依赖配置

使用的Apache POI版本

  1. <poi.version>3.9</poi.version>
  1. <dependency>
  2.     <groupId>org.apache.poi</groupId>
  3.     <artifactId>poi</artifactId>
  4.     <version>${poi.version}</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>org.apache.poi</groupId>
  8.     <artifactId>poi-ooxml</artifactId>
  9.     <version>${poi.version}</version>
  10. </dependency>
  11. <dependency>
  12.     <groupId>org.apache.poi</groupId>
  13.     <artifactId>poi-ooxml-schemas</artifactId>
  14.     <version>${poi.version}</version>
  15. </dependency>

生成XLS格式Excel文档

使用于小数据量生成

  • 受Excel XLS格式文档本身限制(XLS格式文档大约处理最大数据行[65536条])
  • 基于Excel模板写入数据会引发内存溢出

注意：

  • 以下代码少ReportInternalException大家可以忽略(我们封装的一个异常类)
  • 导出的Excel同时考虑到数据的本身类型，如整数、小数、日期等
  • 第一种写入数据方式[writeExcel]方法为直接写入数据
  • 第二种写入数据方式需依次调用方法[writeExcelTitle、writeExcelData]，先完成写入Excel标题与列名，再完成数据写入(或者说基于模板方式写入数据)
  • 第二种方式有内存溢出的可能性
  • 我们使用[styleMap]方法避免重复创建Excel单元格样式(否则受Excel创建样式数量限制)
  1. import org.apache.poi.hssf.usermodel.*;
  2. import org.apache.poi.hssf.util.HSSFColor;
  3. import org.apache.poi.ss.usermodel.*;
  4. import org.apache.poi.ss.util.CellRangeAddress;
  6. import javax.imageio.ImageIO;
  7. import java.io.*;
  8. import java.text.SimpleDateFormat;
  9. import java.util.Date;
  10. import java.util.LinkedHashMap;
  11. import java.util.List;
  12. import java.util.Map;
  14. /**
  15.  * Excel 相关操作类(小数据量写入<=65536)
  16.  */
  17. public class Excel2003Utils {
  19.     private static final int DEFAULT_COLUMN_SIZE = 30;
  21.     /**
  22.      * 断言Excel文件写入之前的条件
  23.      *
  24.      * @param directory 目录
  25.      * @param fileName  文件名
  26.      * @return file
  27.      * @throws IOException
  28.      */
  29.     private static File assertFile(String directory, String fileName) throws IOException {
  30.         File tmpFile = new File(directory + File.separator + fileName + ".xls");
  31.         if (tmpFile.exists()) {
  32.             if (tmpFile.isDirectory()) {
  33.                 throw new IOException("File '" + tmpFile + "' exists but is a directory");
  34.             }
  35.             if (!tmpFile.canWrite()) {
  36.                 throw new IOException("File '" + tmpFile + "' cannot be written to");
  37.             }
  38.         } else {
  39.             File parent = tmpFile.getParentFile();
  40.             if (parent != null) {
  41.                 if (!parent.mkdirs() && !parent.isDirectory()) {
  42.                     throw new IOException("Directory '" + parent + "' could not be created");
  43.                 }
  44.             }
  45.         }
  46.         return tmpFile;
  47.     }
  49.     /**
  50.      * 日期转化为字符串,格式为yyyy-MM-dd HH:mm:ss
  51.      */
  52.     private static String getCnDate(Date date) {
  53.         String format = "yyyy-MM-dd HH:mm:ss";
  54.         SimpleDateFormat sdf = new SimpleDateFormat(format);
  55.         return sdf.format(date);
  56.     }
  58.     /**
  59.      * Excel 导出，POI实现
  60.      *
  61.      * @param fileName    文件名
  62.      * @param sheetName   sheet页名称
  63.      * @param columnNames 表头列表名
  64.      * @param sheetTitle  sheet页Title
  65.      * @param objects     目标数据集
  66.      */
  67.     public static File writeExcel(String directory, String fileName, String sheetName, List<String> columnNames,
  68.                                   String sheetTitle, List<List<Object>> objects, boolean append) throws ReportInternalException, IOException {
  69.         File tmpFile = assertFile(directory, fileName);
  70.         return exportExcel(tmpFile, sheetName, columnNames, sheetTitle, objects, append);
  71.     }
  73.     /**
  74.      * Excel 导出，POI实现，先写入Excel标题，与writeExcelData配合使用
  75.      * 先使用writeExcelTitle再使用writeExcelData
  76.      *
  77.      * @param directory   目录
  78.      * @param fileName    文件名
  79.      * @param sheetName   sheetName
  80.      * @param columnNames 列名集合
  81.      * @param sheetTitle  表格标题
  82.      * @param append      是否在现有的文件追加
  83.      * @return file
  84.      * @throws ReportInternalException
  85.      * @throws IOException
  86.      */
  87.     public static File writeExcelTitle(String directory, String fileName, String sheetName, List<String> columnNames,
  88.                                        String sheetTitle, boolean append) throws ReportInternalException, IOException {
  89.         File tmpFile = assertFile(directory, fileName);
  90.         return exportExcelTitle(tmpFile, sheetName, columnNames, sheetTitle, append);
  91.     }
  93.     /**
  94.      * Excel 导出，POI实现，写入Excel数据行列，与writeExcelTitle配合使用
  95.      * 先使用writeExcelTitle再使用writeExcelData
  96.      *
  97.      * @param directory 目录
  98.      * @param fileName  文件名
  99.      * @param sheetName sheetName
  100.      * @param objects   数据信息
  101.      * @return file
  102.      * @throws ReportInternalException
  103.      * @throws IOException
  104.      */
  105.     public static File writeExcelData(String directory, String fileName, String sheetName, List<List<Object>> objects)
  106.             throws ReportInternalException, IOException {
  107.         File tmpFile = assertFile(directory, fileName);
  108.         return exportExcelData(tmpFile, sheetName, objects);
  109.     }
  111.     /**
  112.      * 导出字符串数据
  113.      *
  114.      * @param file        文件名
  115.      * @param columnNames 表头
  116.      * @param sheetTitle  sheet页Title
  117.      * @param append      是否追加写文件
  118.      * @return file
  119.      * @throws ReportInternalException
  120.      */
  121.     private static File exportExcelTitle(File file, String sheetName, List<String> columnNames,
  122.                                          String sheetTitle, boolean append) throws ReportInternalException, IOException {
  123.         // 声明一个工作薄
  124.         Workbook workBook;
  125.         if (file.exists() && append) {
  126.             // 声明一个工作薄
  127.             workBook = new HSSFWorkbook(new FileInputStream(file));
  128.         } else {
  129.             workBook = new HSSFWorkbook();
  130.         }
  131.         Map<String, CellStyle> cellStyleMap = styleMap(workBook);
  132.         // 表头样式
  133.         CellStyle headStyle = cellStyleMap.get("head");
  134.         // 生成一个表格
  135.         Sheet sheet = workBook.getSheet(sheetName);
  136.         if (sheet == null) {
  137.             sheet = workBook.createSheet(sheetName);
  138.         }
  139.         //最新Excel列索引,从0开始
  140.         int lastRowIndex = sheet.getLastRowNum();
  141.         if (lastRowIndex > 0) {
  142.             lastRowIndex++;
  143.         }
  144.         // 设置表格默认列宽度
  145.         sheet.setDefaultColumnWidth(DEFAULT_COLUMN_SIZE);
  146.         // 合并单元格
  147.         sheet.addMergedRegion(new CellRangeAddress(lastRowIndex, lastRowIndex, 0, columnNames.size() - 1));
  148.         // 产生表格标题行
  149.         Row rowMerged = sheet.createRow(lastRowIndex);
  150.         lastRowIndex++;
  151.         Cell mergedCell = rowMerged.createCell(0);
  152.         mergedCell.setCellStyle(headStyle);
  153.         mergedCell.setCellValue(new HSSFRichTextString(sheetTitle));
  154.         // 产生表格表头列标题行
  155.         Row row = sheet.createRow(lastRowIndex);
  156.         for (int i = 0; i < columnNames.size(); i++) {
  157.             Cell cell = row.createCell(i);
  158.             cell.setCellStyle(headStyle);
  159.             RichTextString text = new HSSFRichTextString(columnNames.get(i));
  160.             cell.setCellValue(text);
  161.         }
  162.         try {
  163.             OutputStream ops = new FileOutputStream(file);
  164.             workBook.write(ops);
  165.             ops.flush();
  166.             ops.close();
  167.         } catch (IOException e) {
  168.             throw new ReportInternalException(e);
  169.         }
  170.         return file;
  171.     }
  173.     /**
  174.      * 导出字符串数据
  175.      *
  176.      * @param file    文件名
  177.      * @param objects 目标数据
  178.      * @return
  179.      * @throws ReportInternalException
  180.      */
  181.     private static File exportExcelData(File file, String sheetName, List<List<Object>> objects) throws ReportInternalException, IOException {
  182.         // 声明一个工作薄
  183.         Workbook workBook;
  184.         if (file.exists()) {
  185.             // 声明一个工作薄
  186.             workBook = new HSSFWorkbook(new FileInputStream(file));
  187.         } else {
  188.             workBook = new HSSFWorkbook();
  189.         }
  190.         Map<String, CellStyle> cellStyleMap = styleMap(workBook);
  191.         // 正文样式
  192.         CellStyle contentStyle = cellStyleMap.get("content");
  193.         //正文整数样式
  194.         CellStyle contentIntegerStyle = cellStyleMap.get("integer");
  195.         //正文带小数整数样式
  196.         CellStyle contentDoubleStyle = cellStyleMap.get("double");
  197.         // 生成一个表格
  198.         Sheet sheet = workBook.getSheet(sheetName);
  199.         if (sheet == null) {
  200.             sheet = workBook.createSheet(sheetName);
  201.         }
  202.         //最新Excel列索引,从0开始
  203.         int lastRowIndex = sheet.getLastRowNum();
  204.         if (lastRowIndex > 0) {
  205.             lastRowIndex++;
  206.         }
  207.         // 设置表格默认列宽度
  208.         sheet.setDefaultColumnWidth(DEFAULT_COLUMN_SIZE);
  209.         // 遍历集合数据,产生数据行,前两行为标题行与表头行
  210.         for (List<Object> dataRow : objects) {
  211.             Row row = sheet.createRow(lastRowIndex);
  212.             lastRowIndex++;
  213.             for (int j = 0; j < dataRow.size(); j++) {
  214.                 Cell contentCell = row.createCell(j);
  215.                 Object dataObject = dataRow.get(j);
  216.                 if (dataObject != null) {
  217.                     if (dataObject instanceof Integer) {
  218.                         contentCell.setCellStyle(contentIntegerStyle);
  219.                         contentCell.setCellValue(Integer.parseInt(dataObject.toString()));
  220.                     } else if (dataObject instanceof Double) {
  221.                         contentCell.setCellStyle(contentDoubleStyle);
  222.                         contentCell.setCellValue(Double.parseDouble(dataObject.toString()));
  223.                     } else if (dataObject instanceof Long && dataObject.toString().length() == 13) {
  224.                         contentCell.setCellStyle(contentStyle);
  225.                         contentCell.setCellValue(getCnDate(new Date(Long.parseLong(dataObject.toString()))));
  226.                     } else if (dataObject instanceof Date) {
  227.                         contentCell.setCellStyle(contentStyle);
  228.                         contentCell.setCellValue(getCnDate((Date) dataObject));
  229.                     } else {
  230.                         contentCell.setCellStyle(contentStyle);
  231.                         contentCell.setCellValue(dataObject.toString());
  232.                     }
  233.                 } else {
  234.                     contentCell.setCellStyle(contentStyle);
  235.                     // 设置单元格内容为字符型
  236.                     contentCell.setCellValue("");
  237.                 }
  238.             }
  239.         }
  240.         try {
  241.             OutputStream ops = new FileOutputStream(file);
  242.             workBook.write(ops);
  243.             ops.flush();
  244.             ops.close();
  245.         } catch (IOException e) {
  246.             throw new ReportInternalException(e);
  247.         }
  248.         return file;
  249.     }
  251.     /**
  252.      * 导出字符串数据
  253.      *
  254.      * @param file        文件名
  255.      * @param columnNames 表头
  256.      * @param sheetTitle  sheet页Title
  257.      * @param objects     目标数据
  258.      * @param append      是否追加写文件
  259.      * @return
  260.      * @throws ReportInternalException
  261.      */
  262.     private static File exportExcel(File file, String sheetName, List<String> columnNames,
  263.                                     String sheetTitle, List<List<Object>> objects, boolean append) throws ReportInternalException, IOException {
  264.         // 声明一个工作薄
  265.         Workbook workBook;
  266.         if (file.exists() && append) {
  267.             // 声明一个工作薄
  268.             workBook = new HSSFWorkbook(new FileInputStream(file));
  269.         } else {
  270.             workBook = new HSSFWorkbook();
  271.         }
  272.         Map<String, CellStyle> cellStyleMap = styleMap(workBook);
  273.         // 表头样式
  274.         CellStyle headStyle = cellStyleMap.get("head");
  275.         // 正文样式
  276.         CellStyle contentStyle = cellStyleMap.get("content");
  277.         //正文整数样式
  278.         CellStyle contentIntegerStyle = cellStyleMap.get("integer");
  279.         //正文带小数整数样式
  280.         CellStyle contentDoubleStyle = cellStyleMap.get("double");
  281.         // 生成一个表格
  282.         Sheet sheet = workBook.getSheet(sheetName);
  283.         if (sheet == null) {
  284.             sheet = workBook.createSheet(sheetName);
  285.         }
  286.         //最新Excel列索引,从0开始
  287.         int lastRowIndex = sheet.getLastRowNum();
  288.         if (lastRowIndex > 0) {
  289.             lastRowIndex++;
  290.         }
  291.         // 设置表格默认列宽度
  292.         sheet.setDefaultColumnWidth(DEFAULT_COLUMN_SIZE);
  293.         // 合并单元格
  294.         sheet.addMergedRegion(new CellRangeAddress(lastRowIndex, lastRowIndex, 0, columnNames.size() - 1));
  295.         // 产生表格标题行
  296.         Row rowMerged = sheet.createRow(lastRowIndex);
  297.         lastRowIndex++;
  298.         Cell mergedCell = rowMerged.createCell(0);
  299.         mergedCell.setCellStyle(headStyle);
  300.         mergedCell.setCellValue(new HSSFRichTextString(sheetTitle));
  301.         // 产生表格表头列标题行
  302.         Row row = sheet.createRow(lastRowIndex);
  303.         lastRowIndex++;
  304.         for (int i = 0; i < columnNames.size(); i++) {
  305.             Cell cell = row.createCell(i);
  306.             cell.setCellStyle(headStyle);
  307.             RichTextString text = new HSSFRichTextString(columnNames.get(i));
  308.             cell.setCellValue(text);
  309.         }
  310.         // 遍历集合数据,产生数据行,前两行为标题行与表头行
  311.         for (List<Object> dataRow : objects) {
  312.             row = sheet.createRow(lastRowIndex);
  313.             lastRowIndex++;
  314.             for (int j = 0; j < dataRow.size(); j++) {
  315.                 Cell contentCell = row.createCell(j);
  316.                 Object dataObject = dataRow.get(j);
  317.                 if (dataObject != null) {
  318.                     if (dataObject instanceof Integer) {
  319.                         contentCell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
  320.                         contentCell.setCellStyle(contentIntegerStyle);
  321.                         contentCell.setCellValue(Integer.parseInt(dataObject.toString()));
  322.                     } else if (dataObject instanceof Double) {
  323.                         contentCell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
  324.                         contentCell.setCellStyle(contentDoubleStyle);
  325.                         contentCell.setCellValue(Double.parseDouble(dataObject.toString()));
  326.                     } else if (dataObject instanceof Long && dataObject.toString().length() == 13) {
  327.                         contentCell.setCellType(HSSFCell.CELL_TYPE_STRING);
  328.                         contentCell.setCellStyle(contentStyle);
  329.                         contentCell.setCellValue(getCnDate(new Date(Long.parseLong(dataObject.toString()))));
  330.                     } else if (dataObject instanceof Date) {
  331.                         contentCell.setCellType(HSSFCell.CELL_TYPE_STRING);
  332.                         contentCell.setCellStyle(contentStyle);
  333.                         contentCell.setCellValue(getCnDate((Date) dataObject));
  334.                     } else {
  335.                         contentCell.setCellType(HSSFCell.CELL_TYPE_STRING);
  336.                         contentCell.setCellStyle(contentStyle);
  337.                         contentCell.setCellValue(dataObject.toString());
  338.                     }
  339.                 } else {
  340.                     contentCell.setCellStyle(contentStyle);
  341.                     // 设置单元格内容为字符型
  342.                     contentCell.setCellValue("");
  343.                 }
  344.             }
  345.         }
  346.         try {
  347.             OutputStream ops = new FileOutputStream(file);
  348.             workBook.write(ops);
  349.             ops.flush();
  350.             ops.close();
  351.         } catch (IOException e) {
  352.             throw new ReportInternalException(e);
  353.         }
  354.         return file;
  355.     }
  357.     /**
  358.      * 创建单元格表头样式
  359.      *
  360.      * @param workbook 工作薄
  361.      */
  362.     private static CellStyle createCellHeadStyle(Workbook workbook) {
  363.         CellStyle style = workbook.createCellStyle();
  364.         // 设置边框样式
  365.         style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  366.         style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  367.         style.setBorderRight(HSSFCellStyle.BORDER_THIN);
  368.         style.setBorderTop(HSSFCellStyle.BORDER_THIN);
  369.         //设置对齐样式
  370.         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  371.         // 生成字体
  372.         Font font = workbook.createFont();
  373.         // 表头样式
  374.         style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  375.         style.setFillForegroundColor(HSSFColor.GREY_25_PERCENT.index);
  376.         font.setFontHeightInPoints((short) 12);
  377.         font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
  378.         // 把字体应用到当前的样式
  379.         style.setFont(font);
  380.         return style;
  381.     }
  383.     /**
  384.      * 创建单元格正文样式
  385.      *
  386.      * @param workbook 工作薄
  387.      */
  388.     private static CellStyle createCellContentStyle(Workbook workbook) {
  389.         CellStyle style = workbook.createCellStyle();
  390.         // 设置边框样式
  391.         style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  392.         style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  393.         style.setBorderRight(HSSFCellStyle.BORDER_THIN);
  394.         style.setBorderTop(HSSFCellStyle.BORDER_THIN);
  395.         //设置对齐样式
  396.         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  397.         // 生成字体
  398.         Font font = workbook.createFont();
  399.         // 正文样式
  400.         style.setFillPattern(HSSFCellStyle.NO_FILL);
  401.         style.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  402.         font.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
  403.         // 把字体应用到当前的样式
  404.         style.setFont(font);
  405.         return style;
  406.     }
  408.     /**
  409.      * 单元格样式(Integer)列表
  410.      */
  411.     private static CellStyle createCellContent4IntegerStyle(Workbook workbook) {
  412.         CellStyle style = workbook.createCellStyle();
  413.         // 设置边框样式
  414.         style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  415.         style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  416.         style.setBorderRight(HSSFCellStyle.BORDER_THIN);
  417.         style.setBorderTop(HSSFCellStyle.BORDER_THIN);
  418.         //设置对齐样式
  419.         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  420.         // 生成字体
  421.         Font font = workbook.createFont();
  422.         // 正文样式
  423.         style.setFillPattern(HSSFCellStyle.NO_FILL);
  424.         style.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  425.         font.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
  426.         // 把字体应用到当前的样式
  427.         style.setFont(font);
  428.         style.setDataFormat(HSSFDataFormat.getBuiltinFormat("#,##0"));//数据格式只显示整数
  429.         return style;
  430.     }
  432.     /**
  433.      * 单元格样式(Double)列表
  434.      */
  435.     private static CellStyle createCellContent4DoubleStyle(Workbook workbook) {
  436.         CellStyle style = workbook.createCellStyle();
  437.         // 设置边框样式
  438.         style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  439.         style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  440.         style.setBorderRight(HSSFCellStyle.BORDER_THIN);
  441.         style.setBorderTop(HSSFCellStyle.BORDER_THIN);
  442.         //设置对齐样式
  443.         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  444.         // 生成字体
  445.         Font font = workbook.createFont();
  446.         // 正文样式
  447.         style.setFillPattern(HSSFCellStyle.NO_FILL);
  448.         style.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  449.         font.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
  450.         // 把字体应用到当前的样式
  451.         style.setFont(font);
  452.         style.setDataFormat(HSSFDataFormat.getBuiltinFormat("#,##0.00"));//保留两位小数点
  453.         return style;
  454.     }
  456.     /**
  457.      * 单元格样式列表
  458.      */
  459.     private static Map<String, CellStyle> styleMap(Workbook workbook) {
  460.         Map<String, CellStyle> styleMap = new LinkedHashMap<>();
  461.         styleMap.put("head", createCellHeadStyle(workbook));
  462.         styleMap.put("content", createCellContentStyle(workbook));
  463.         styleMap.put("integer", createCellContent4IntegerStyle(workbook));
  464.         styleMap.put("double", createCellContent4DoubleStyle(workbook));
  465.         return styleMap;
  466.     }
  468. }
使用例子
  1. import java.io.IOException;
  2. import java.sql.Date;
  3. import java.util.LinkedList;
  4. import java.util.List;
  6. /**
  7.  * Excel2003Test
  8.  * Created by jianwei.zhou on 2016/11/9.
  9.  */
  10. public class Excel2003Test {
  12.     public static void main(String[] args) throws IOException {
  13.         String sheetName = "测试Excel格式";
  14.         String sheetTitle = "测试Excel格式";
  15.         List<String> columnNames = new LinkedList<>();
  16.         columnNames.add("日期-String");
  17.         columnNames.add("日期-Date");
  18.         columnNames.add("时间戳-Long");
  19.         columnNames.add("客户编码");
  20.         columnNames.add("整数");
  21.         columnNames.add("带小数的正数");
  23.         //写入标题--第二种方式
  24.         Excel2003Utils.writeExcelTitle("E:\\temp", "a", sheetName, columnNames, sheetTitle, false);
  26.         List<List<Object>> objects = new LinkedList<>();
  27.         for (int i = 0; i < 1000; i++) {
  28.             List<Object> dataA = new LinkedList<>();
  29.             dataA.add("2016-09-05 17:27:25");
  30.             dataA.add(new Date(1451036631012L));
  31.             dataA.add(1451036631012L);
  32.             dataA.add("000628");
  33.             dataA.add(i);
  34.             dataA.add(1.323 + i);
  35.             objects.add(dataA);
  36.         }
  37.         try {
  38.             //写入数据--第二种方式
  39.             Excel2003Utils.writeExcelData("E:\\temp", "a", sheetName, objects);
  41.             //直接写入数据--第一种方式
  42.             Excel2003Utils.writeExcel("E:\\temp", "a", sheetName, columnNames, sheetTitle, objects, false);
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.         }
  47.     }
  48. }
  50. from: http://www.jianshu.com/p/e5e1d82a3775

使用Apache POI导出Excel小结--导出XLS格式文档的更多相关文章

  1. apache POI 操作excel<导入导出>

    1.首先导入maven依赖 <!-- POI核心依赖 --> <dependency> <groupId>org.apache.poi</groupId> ...

  2. PHP 导出 Excel 兼容 CSV XlS格式

    class ExcelRead { /** * 获取Excel文件内容 * @param $file * @return mixed * @throws PHPExcel_Reader_Excepti ...

  3. 关于poi导出excel方式HSSFWorkbook(xls).XSSFWorkbook(xlsx).SXSSFWorkbook.csv的总结

    1.HSSFWorkbook(xls) import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermo ...

  4. 【原创】POI操作Excel导入导出工具类ExcelUtil

    关于本类线程安全性的解释: 多数工具方法不涉及共享变量问题,至于添加合并单元格方法addMergeArea,使用ThreadLocal变量存储合并数据,ThreadLocal内部借用Thread.Th ...

  5. SpringBoot集成文件 - 集成POI之Excel导入导出

    Apache POI 是用Java编写的免费开源的跨平台的 Java API,Apache POI提供API给Java程序对Microsoft Office格式档案读和写的功能.本文主要介绍通过Spr ...

  6. Java开发小技巧（六）：使用Apache POI读取Excel

    前言 在数据仓库中,ETL最基础的步骤就是从数据源抽取所需的数据,这里所说的数据源并非仅仅是指数据库,还包括excel.csv.xml等各种类型的数据接口文件,而这些文件中的数据不一定是结构化存储的, ...

  7. 项目一:第四天 1、快递员的条件分页查询-noSession,条件查询 2、快递员删除（逻辑删除） 3、基于Apache POI实现批量导入区域数据 a)Jquery OCUpload上传文件插件使用 b)Apache POI读取excel文件数据

    1. 快递员的条件分页查询-noSession,条件查询 2. 快递员删除(逻辑删除) 3. 基于Apache POI实现批量导入区域数据 a) Jquery OCUpload上传文件插件使用 b) ...

  8. 利用Apache POI操作Excel

    最近在做接口,有个功能是利用Excel导入汽车发动机所需零件信息到线上系统中.简单回顾一下之前学过的用java操作Excel. 1.maven配置Apache POI pom.xml中配置POIjar ...

  9. 数据库数据怎样导出成Excle表格或Word文档？

    数据导出:将数据库的数据导出成Excel工作表或Word文档 方法:将一个泛型集合导出出去 主要使用: SaveFileDialog StreamWriter 导出代码: private void b ...

随机推荐

  1. APP运营

    产品相关术语 APP:application的简写,即应用. 开发商:也叫CP,即ContentProvider内容提供商. 发行商(运营商):代理CP开发出来的产品. 联运:CP和渠道联合运营产品. ...

  2. django-1366, "Incorrect string value: '\\xE6\\x88\\x9A\\xE4\\xBC\\x9F...'

    今天把之前的一些代码转移到另外一台电脑的时候, python manage.py syncdb 的时候报了 (1366, "Incorrect string value: '\\xE6\\x ...

  3. Myeclipse实用快捷键总结

    alt+shift+J 为选中的类/方法添加注释 ctrl+T 显示选中类的继承树 ctrl+shift+X/Y 将选中的字符转换为大写/小写 ctrl+shift+R 打开资源 ctrl+shift ...

  4. hdu 2147(巴什博弈+NP图)

    kiki's game Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 40000/10000 K (Java/Others)Total ...

  5. python中global变量释疑

    疑问 为什么main中不能写global x语句? 在函数中如何修改global变量? 在main中修改了global变量后,在子进程中为什么没有效果? 如何利用进程池的initializer参数(函 ...

  6. 无法使用命令 /usr/bin/xdpyinfo 自动检查显示器颜色。请检查是否设置了 DISPLAY

    https://blog.csdn.net/woshigedahaoren/article/details/9493887

  7. sqlserver 构架与性能优化

    太阳底下没有新鲜事 一.sqlserver 构架结构 1.查询优化器三阶段 1).找计划缓存如果找到直接使用 2).简单语句生成0开销的执行计划 3).正式优化 一般情况下优化到开销小于1.0就会停止 ...

  8. Linux和Windows双系统安装要点

    这里主要说下CentOS和Windows7的双系统安装遇到的一些问题 一.磁盘分区 这个不得不说下在Windows下坑爹的设定了,如果是用默认的磁盘划分,系统会自己先划出一个100M左右的区,关键还是 ...

  9. T-SQL备忘(6)：常用内置函数

    日期和时间函数: 1.获取当前时间:GETDATE() select GETDATE() 返回: 2015-04-27 20:52:06.700 2.返回时间的部分(日.月.年) a.获取日: sel ...

  10. lr计算程序执行消耗时间的比较：

    去除程序执行的两种方式: 1.通过一个事务:在需要消除的代码段,使用lr_wasted_time(wasteTime); querySubmit() { char newStr4[10000]=&qu ...