JAVA导入/出EXCEL表格 POI

---

POI简介：

---

目前最新版本是Apache POI 4.1.0（Apache POI团队于2019年4月9日宣布发布），个人觉得旧版本中的3.6版比较稳定。

自版本POI 4.0.1起，POI需要Java 8或更高版本。

POI 3.11及更高版本3.x版本需要JDK 1.6或更高版本。

POI 3.5到3.10需要JDK 1.5或更高版本。3.5之前的版本需要JDK 1.4+。

Apache POI是Apache软件基金会的开放源码函式库项目---Jakarta。

===========================================================

POI 是一套用Java编写的免费开源的跨平台的 Java API；用于给Java程序，访问微软格式文档Microsoft Office，读和写的功能的Java API。Jakarta POI由以下组件组成：

poi-ooxml需要poi-ooxml-schemas。这是ooxml-schemas jar的一个小得多的版本（POI 4.0.0或更高版本的ooxml-schemas-1.4.jar，POI 3.14或POI 3.17的ooxml-schemas-1.3.jar，ooxml-schemas-1.1.jar对于POI 3.7至POI 3.13，ooxml-schemas-1.0.jar为POI 3.5和3.6）。较大的ooxml-schemas jar 通常 仅用于开发。类似地，ooxml-security jar包含所有与加密和签名相关的类，通常只需要进行开发。其内容的一部分是poi-ooxml-schemas。此JAR是POI 3.14以后的ooxml-security-1.1.jar和之前的ooxml-security-1.0.jar。

OOXML jar需要stax实现，但是现在Apache POI需要Java 8，JRE提供了该依赖，并且不需要额外的stax jar。OOXML jar用于需要DOM4J，但代码现已更改为使用JAXP，并且不需要额外的dom4j jar。顺便说一下， 如果在使用非Oracle JDK时遇到问题，请查看此FAQ。

ooxml模式jar使用Apache XMLBeans 2.3 进行编译，因此可以在运行时使用3.0.0或更高版本的任何版本的XMLBeans。尽管如此，我们建议您将XMLBeans 3.1.0与Apache POI一起使用，这是二进制发行包中现在提供的版本。

• HSSF提供读写Microsoft Excel XLS格式档案的功能。
• XSSF提供读写Microsoft Excel OOXML XLSX格式档案的功能。
• HWPF提供读写Microsoft Word DOC格式档案的功能。
• HSLF提供读写Microsoft PowerPoint格式档案的功能。
• HDGF提供读Microsoft Visio格式档案的功能。
• HPBF提供读Microsoft Publisher格式档案的功能。
• HSMF提供读Microsoft Outlook格式档案的功能。

---

Why should I use Apache POI?

我为什么要使用Apache POI？

A major use of the Apache POI api is for Text Extraction(文本提取) applications such as web spiders, index builders, and content management systems.

Apache POI api的主要用途是用于文本提取应用程序，例如网页爬虫，索引构建器和内容管理系统。

So why should you use POIFS, HSSF or XSSF?

那么为什么要使用POIFS，HSSF或XSSF？

You'd use POIFS if you had a document written in OLE 2 Compound Document Format, probably written using MFC, that you needed to read in Java. Alternatively, you'd use POIFS to write OLE 2 Compound Document Format if you needed to inter-operate with software running on the Windows platform. We are not just bragging when we say that POIFS is the most complete and correct implementation of this file format to date!

如果您有一个用OLE 2复合文档格式编写的文档（可能是使用MFC编写的），那么您需要使用POIFS。或者，如果需要与Windows平台上运行的软件进行互操作，则可以使用POIFS编写OLE 2复合文档格式。当我们说POIFS是迄今为止最完整和正确的文件格式实现时，我们不只是吹牛！

You'd use HSSF if you needed to read or write an Excel file using Java (XLS). You'd use XSSF if you need to read or write an OOXML Excel file using Java (XLSX). The combined SS interface allows you to easily read and write all kinds of Excel files (XLS and XLSX) using Java. Additionally there is a specialized SXSSF implementation which allows to write very large Excel (XLSX) files in a memory optimized way.

如果需要使用Java（XLS）读取或写入Excel文件，则可以使用HSSF。如果需要使用Java（XLSX）读取或写入OOXML Excel文件，则可以使用XSSF。组合的SS接口允许您使用Java轻松读取和写入各种Excel文件（XLS和XLSX）。此外，还有一个专门的SXSSF实现，允许以内存优化的方式编写非常大的Excel（XLSX）文件。

--------------------------------------------------------------------------------------------------  摘自  Apache P O I 官网

用POI导出Excel我们首先要下载所需的jar包然后导入到我们的项目中

1.下载jar包并将其引入到项目中

<!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>4.1.0</version>
        </dependency>

小提示：用maven引入依赖jar包的可能会遇到包引用不到的bug，但是maven依赖确实已经引入了，而且没有任何报错，但是只要一引用  org.apache.poi.hssf.usermodel下面的类,就会报错，报错内容为：Caused by: java.lang.NoClassDefFoundError: org/apache/poi/hssf/usermodel/HSSFWorkbook。

下面这个jar包也不可少哟

<!-- https://mvnrepository.com/artifact/nz.ac.waikato.cms.weka/WekaExcel -->
<dependency>
    <groupId>nz.ac.waikato.cms.weka</groupId>
    <artifactId>WekaExcel</artifactId>
    <version>1.0.6</version>
</dependency>

【可以换个版本号    试试】

<!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.6</version>
        </dependency>

2.Jakarta POI HSSF API组件:

HSSF（用于操作Excel的组件）提供给用户使用的对象在rg.apache.poi.hssf.usermodel包中,主要部分包括Excel对象，样式和格式，有以下几种常用的对象：

类名	说明
HSSFWorkbook	excel的文档对象
HSSFSheet	excel的表单
HSSFRow	excel的行
HSSFCell	excel的格子单元
HSSFFont	excel字体
HSSFDataFormat	格子单元的日期格式
HSSFHeader	Excel文档Sheet的页眉
HSSFFooter	Excel文档Sheet的页脚
HSSFCellStyle	格子单元样式
HSSFDateUtil	日期
HSSFPrintSetup	打印
HSSFErrorConstants	错误信息表

3. 基本操作步骤：

首先，我们应该要知道的是，一个Excel文件对应一个workbook，一个workbook中有多个sheet组成，一个sheet是由多个行(row)和列(cell)组成。那么我们用poi要导出一个Excel表格的正确顺序应该是：

1.  用HSSFWorkbook打开或者创建“Excel文件对象”

2.  用HSSFWorkbook对象返回或者创建Sheet对象

3.  用Sheet对象返回行对象，用行对象得到Cell对象

4.  对Cell对象读写。

5. 将生成的HSSFWorkbook放入HttpServletResponse中响应到前端页面

---

创建Excel 文档

package com.epoch.ecxelreporthanlder.utils;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import java.io.FileOutputStream;

public class CreatExcel {
    /**
     * Excel文件要存放的位置
     * 使用Java（XLSX）读取或写入OOXML Excel文件，则可以使用XSSF;
     * 使用Java（XLS）读取或写入Excel文件，则可以使用HSSF
     */
    public static String outputFile = "D:\\ExcelUtils\\POI\\test.xls";

    public static void main(String argv[]) {
        try {
            /* 第一步，用HSSFWorkbook创建“Excel文件对象”*/
            HSSFWorkbook workbook = new HSSFWorkbook();
            /* 第二步，用HSSFWorkbook对象workbook创建Sheet对象，其(工作表)名称为缺省值*/
            // 如要新建一名为"Sheet1"的工作表，其语句为：
            // HSSFSheet sheet = workbook.createSheet("Sheet1");
            HSSFSheet sheet = workbook.createSheet();
            /*第三步，用Sheet对象返回行对象，用行对象得到Cell对象*/
            // 在索引0的位置创建行（最顶端的行）
            HSSFRow row = sheet.createRow((short) 0);
            //在索引0的位置创建单元格（左上端）
            HSSFCell cell = row.createCell((short) 0);
            /*第四步，对cell对象读写*/
            // 定义单元格为字符串类型
            cell.setCellType(HSSFCell.CELL_TYPE_STRING);//已过时
            // 在单元格中输入一些内容
            cell.setCellValue("第一个单元格");
            // 新建一输出文件流
            FileOutputStream fOut = new FileOutputStream(outputFile);
            // 把相应的Excel 工作簿存盘
            workbook.write(fOut);
            fOut.flush();
            // 操作结束，关闭文件
            fOut.close();
            System.out.println("文件已成功生成..."+outputFile);
        }
        catch (Exception e) {
            System.out.println("已运行 xlCreate() : " + e);
        }
    }

}

读取Excel文档中的数据

package com.epoch.ecxelreporthanlder.utils;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFCell;

import java.io.FileInputStream;

/**
 * 读取生成的Excel文件
 */
public class ReadExcel {
    /**
     * Excel文件的存放位置。注意是反斜线
     */
    public static String fileToBeRead = "D:\\ExcelUtils\\POI\\test.xls";

    public static void main(String argv[]) {
        try {
            // 创建对Excel工作簿文件的引用
            HSSFWorkbook workbook = new HSSFWorkbook(new FileInputStream(fileToBeRead));
            // 创建对工作表的引用。
            // 本例是按名引用（让我们假定那张表有着缺省名"Sheet1"）
            HSSFSheet sheet = workbook.getSheet("Sheet1");
            // 也可用getSheetAt(int index)按索引引用，
            // 在Excel文档中，第一张工作表的缺省索引是0，
            // 其语句为：HSSFSheet sheet = workbook.getSheetAt(0);
            // 读取左上端单元
            HSSFRow row = sheet.getRow(0);
            HSSFCell cell = row.getCell((short) 0);
            // 输出单元内容，cell.getStringCellValue()就是取所在单元的值
            System.out.println("左上端单元是： " + cell.getStringCellValue());
        }catch (Exception e) {
            System.out.println("已运行xlRead() : " + e);
        }
    }
}

设置单元格格式

在这里，我们将只介绍一些和格式设置有关的语句，我们假定workbook就是对一个工作簿的引用。在Java中，第一步要做的就是创建和设置字体和单元格的格式，然后再应用这些格式：

1、创建字体，设置其为红色、粗体：

HSSFFont font = workbook.createFont();
font.setColor(HSSFFont.COLOR_RED);
font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);

2、创建格式

HSSFCellStyle cellStyle= workbook.createCellStyle();
cellStyle.setFont(font);

3、应用格式

// 在索引0的位置创建单元格（左上端）
HSSFCell cell = row.createCell((short) 0);
// 设置单元格样式
cell.setCellStyle(cellStyle);
// 定义单元格为字符串类型
cell.setCellType(HSSFCell.CELL_TYPE_STRING);//已过时
// 在单元格中输入一些内容
cell.setCellValue("标题 ");

4. 导出Excel应用实例：

eg1.ExportExcelUtil

package com.epoch.ecxelreporthanlder.utils;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.FillPatternType;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.*;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;

public class ExportExcelUtil {
    /**
     * 导出Excel
     * 使用Java（XLSX）读取或写入OOXML Excel文件，则可以使用XSSF;
     * 使用Java（XLS）读取或写入Excel文件，则可以使用HSSF
     * @param sheetName sheet名称
     * @param header
     * @param title 标题
     * @param values 内容
     * @param wb XSSFWorkbook对象
     * @return
     */
    public static XSSFWorkbook getXSSFWorkbook(String sheetName, String header, String[] title, String[][] values, XSSFWorkbook wb) {

        /**
         * 导出步骤
         */
        // 第一步，用XSSFWorkbook打开或者创建“Excel文件对象”即 创建一个XSSFWorkbook就对应一个Excel
        if (wb == null) {
            wb = new XSSFWorkbook();
        }

        // 第二步，在workbook中添加一个sheet,对应Excel文件中的sheet
        XSSFSheet sheet = wb.getSheet(sheetName);

        // 第三步，用Sheet对象返回行对象，用行对象得到Cell对象
        //在sheet中添加表头第0行,注意老版本poi对Excel的行数列数有限制
        XSSFRow row = sheet.createRow(0);

        XSSFCell cell;
        cell = row.createCell(0);
        cell.setCellValue(header);

        //第四步，声明cell(列)对象,并对其读写
        // 表头标题样式
        XSSFFont headFont = wb.createFont();
        headFont.setFontName("宋体");
        // 字体加粗
        headFont.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
        // 字体大小
        headFont.setFontHeightInPoints((short) 20);
        XSSFCellStyle headStyle = wb.createCellStyle();
        headStyle.setFont(headFont);
        // 左右居中
        headStyle.setAlignment(XSSFCellStyle.ALIGN_CENTER);
        // 上下居中
        headStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
        headStyle.setLocked(true);
        //起始行号，终止行号， 起始列号，终止列号
        sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, title.length - 1));
        row.setHeight((short) 0x480);
        cell.setCellStyle(headStyle);


        //内容样式
        XSSFFont valueFont = wb.createFont();
        valueFont.setFontName("微软雅黑");
        // 字体大小
        valueFont.setFontHeightInPoints((short) 10);
        XSSFCellStyle valueStyle = wb.createCellStyle();
        valueStyle.setFont(valueFont);
        // 左右居中
        valueStyle.setAlignment(XSSFCellStyle.ALIGN_CENTER);
        // 上下居中
        valueStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
        valueStyle.setLocked(true);
        //边框
        valueStyle.setBorderBottom(BorderStyle.THIN);
        valueStyle.setBorderLeft(BorderStyle.THIN);
        valueStyle.setBorderRight(BorderStyle.THIN);
        valueStyle.setBorderTop(BorderStyle.THIN);

        //标题样式
        XSSFFont titleFont = wb.createFont();
        titleFont.setFontName("宋体");
        // 字体加粗
        titleFont.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
        // 字体大小
        titleFont.setFontHeightInPoints((short) 13);
        XSSFCellStyle titleStyle = wb.createCellStyle();
        titleStyle.setFont(titleFont);
        titleStyle.setFillForegroundColor(IndexedColors.LIGHT_GREEN.getIndex());
        //填充方案
        titleStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        // 左右居中
        titleStyle.setAlignment(XSSFCellStyle.ALIGN_CENTER);
        // 上下居中
        titleStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
        titleStyle.setLocked(true);
        //边框
        titleStyle.setBorderBottom(BorderStyle.THIN);
        titleStyle.setBorderLeft(BorderStyle.THIN);
        titleStyle.setBorderRight(BorderStyle.THIN);
        titleStyle.setBorderTop(BorderStyle.THIN);

        XSSFRow row1 = sheet.createRow(1);
        row1.setHeight((short) 0x150);
        //创建标题
        for (int i = 0; i < title.length; i++) {
            cell = row1.createCell(i);
            cell.setCellValue(title[i]);
            cell.setCellStyle(titleStyle);
        }

        //创建内容
        for (int i = 0; i < values.length; i++) {
            row = sheet.createRow(i + 2);
            for (int j = 0; j < values[i].length; j++) {
                //将内容按顺序赋给对应的列对象
                XSSFCell valueCell = row.createCell(j);
                valueCell.setCellValue(values[i][j]);
                valueCell.setCellStyle(valueStyle);
            }
            //设置行高
            row.setHeight((short) 0x130);
        }
        return wb;
    }

    //第五步，发送响应流方法，将生成的XSSFWorkbook放入HttpServletResponse中并响应到前端页面
    public static void setResponseHeader(HttpServletResponse response, String fileName, XSSFWorkbook wb) {

        response.setContentType("application/vnd.ms-excel;charset=utf-8");
        try {
            response.setHeader("Content-Disposition", "attachment;filename=" + fileName.getBytes("utf-8"));
            /*response.addHeader("Pargam", "no-cache");
            response.addHeader("Cache-Control", "no-cache");*/
            OutputStream os;
            os = response.getOutputStream();
            wb.write(os);
            os.flush();
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

eg2.ExcelHanlder

package com.epoch.ccpayment.utils;

import org.apache.poi.xssf.usermodel.*;

import java.util.List;
import java.util.Map;

/**
 * excel处理
 *
 * @author LJJ
 * 2019-07-05
 */

public class ExcelHanlder {
    //默认高度
    private static short DEFAULT_ROW_HEIGHT = 400;
    //默认宽度
    private static int DEFAULT_CELL_WIDTH = 3000;

    /**
     * @param book         工作簿对象，【可选】
     * @param hanlder      自定义类型处理【可选】
     * @param titles       标题
     * @param columns      列名（Map类型处理，自定义可选）
     * @param columnsWidth 宽度
     * @param height       行高
     * @param sheetTitle   表标题
     * @param datas        数据
     * @return
     */
    @SuppressWarnings("all")
    public static XSSFWorkbook exportExcel(XSSFWorkbook book, ExcelTypeHanlder hanlder, String[] titles, String[] columns, Integer[] columnsWidth, Short height, String sheetTitle, List datas) {
        if (book == null) {
            book = new XSSFWorkbook();
        }
        int size = DEFAULT_CELL_WIDTH;
        //列大小
        if (columnsWidth != null && columnsWidth.length == 1) {
            size = columnsWidth[0];
        }
        if (height == null) {
            height = DEFAULT_ROW_HEIGHT;
        }
        XSSFSheet sheet = book.createSheet(sheetTitle);
        int rowindex = 0;
        XSSFRow firstrow = sheet.createRow(rowindex);
        rowindex++;
        sheet.setDefaultColumnWidth(size);
        firstrow.setHeight(height);

        XSSFFont font = book.createFont();
        font.setBold(true);
        XSSFCellStyle cellstyle = book.createCellStyle();
        cellstyle.setFont(font);
        cellstyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
        //标题
        if (titles != null) {
            int index = 0;
            for (String title : titles) {
                XSSFCell cell = firstrow.createCell(index);
                cell.setCellStyle(cellstyle);
                cell.setCellValue(title);
                //列宽度设置
                if (columnsWidth == null || columnsWidth.length == 0 || columnsWidth.length == 1) {
                    sheet.setColumnWidth(cell.getColumnIndex(), size);
                }
                else {
                    if ((columnsWidth.length - 1) >= index) {
                        sheet.setColumnWidth(cell.getColumnIndex(), columnsWidth[index] == null ? size : columnsWidth[index]);
                    }
                    else {
                        sheet.setColumnWidth(cell.getColumnIndex(), size);
                    }
                }
                index++;
            }
        }
        if (datas == null) {
            return book;
        }
        //写入数据
        for (Object data : datas) {
            //map 类型处理
            if (data instanceof Map) {
                Map<String, Object> map = (Map<String, Object>) data;
                XSSFRow row = sheet.createRow(rowindex);
                int i = 0;
                for (String column : columns) {
                    XSSFCell cell = row.createCell(i);
                    Object val = map.get(column);
                    if (hanlder != null && val == null) {
                        Object temp = hanlder.dataNullHander(column, map);
                        cell.setCellValue(temp != null ? temp.toString() : "");
                    }
                    else {
                        cell.setCellValue(val != null ? val.toString() : "");
                    }
                    i++;
                }
                row.setHeight(DEFAULT_ROW_HEIGHT);
                rowindex++;
            }
            else {
                //其他处理
                if (hanlder != null) {
                    Object obj = data;
                    XSSFRow row = sheet.createRow(rowindex);
                    hanlder.typeHanlder(data, row);
                    rowindex++;
                }
            }
        }
        return book;
    }

    /**
     * @param book       工作簿对象，【可选】
     * @param titles     标题
     * @param columns    列名（Map类型处理，自定义可选）
     * @param sheetTitle 表标题
     * @param datas      数据
     * @return
     */
    public static XSSFWorkbook exportExcel(XSSFWorkbook book, String[] titles, String[] columns, String sheetTitle, List<Map<String, String>> datas) {
        return exportExcel(book, null, titles, columns, null, null, sheetTitle, datas);
    }

    /**
     * @param titles     标题
     * @param columns    列名（Map类型处理，自定义可选）
     * @param sheetTitle 表标题
     * @param datas      数据
     * @return
     */
    @SuppressWarnings("all")
    public static XSSFWorkbook exportExcel(String[] titles, String[] columns, String sheetTitle, List<Map<String, String>> datas, ExcelTypeHanlder hanlder) {
        return exportExcel(null, hanlder, titles, columns, null, null, sheetTitle, datas);
    }

    public static XSSFWorkbook exportExcel(String[] titles, String[] columns, String sheetTitle, List<Map<String, String>> datas) {
        return exportExcel(null, null, titles, columns, null, null, sheetTitle, datas);
    }

    //自定义处理对象回调
    public static abstract class ExcelTypeHanlder<T> {
        //类型处理
        public void typeHanlder(T data, XSSFRow row) {
        }

        //空数据处理
        public Object dataNullHander(String column, T obj) {
            return null;
        }
    }
}

https://blog.csdn.net/u012431703/article/details/94716983