常用场景

1. 将用户信息导出为excel表格
2. 将excel的信息导入到数据库，减轻大量网站录入量 开发经常使用到excel导入导出

Apache POI官网：

https://poi.apache.org/ 比较麻烦

Apache POI项目的任务是创建和维护Java API，以基于Office Open
XML标准（OOXML）和Microsoft的OLE 2复合文档格式（OLE2）来处理各种文件格式。简而言之，您可以使用Java读写MS
Excel文件。此外，您可以使用Java读写MS Word和MS PowerPoint文件。Apache POI是您的Java Excel解决方案（适用于Excel 97-2008）。

easyexcel官网：

https://github.com/alibaba/easyexcel

POI使用

1. 创建普通的maven项目
2. 导入依赖

<dependencies>
        <!--xls 03-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.9</version>
        </dependency>
        <!--xls 07-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.9</version>
        </dependency>
        <!--日期格式化工具-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.5</version>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

xls03和xls07的区别 ： 数据量的大小 03的只有65535行

03版本的：

创建测试类

static String path="H:\\CSDN\\POI\\src\\main\\java\\com\\dj";
    @Test
    public void testWrite03() throws IOException {
        //1. 创建工作簿
        Workbook workbook=new HSSFWorkbook();
        //2. 创建工作表 参数：表的名称
        Sheet sheet=workbook.createSheet("joker_djの表");
        //3. 创建一个行
        Row row1=sheet.createRow(0);
        //4. 创建一个单元格
        Cell cell1 = row1.createCell(0);//第一行的第一列
        cell1.setCellValue("姓名");//设置值
        Cell cell2 = row1.createCell(1);//第一行的第二列
        cell2.setCellValue("joker_dj");//设置值

        //第二行
        Row row2=sheet.createRow(1);
        //4. 创建一个单元格
        Cell cell21 = row2.createCell(0);//第二行的第一列
        cell21.setCellValue("统计时间");//设置值
        Cell cell22 = row2.createCell(1);//第二行的第二列
        String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
        cell22.setCellValue(time);//设置值

        //生成一张表
        FileOutputStream fileOutputStream = new FileOutputStream(path + "/统计表03.xls");
        workbook.write(fileOutputStream);//输出文件内容
        //关闭流
        fileOutputStream.close();
        System.out.println("文件输出完毕");
    }

输出效果

07版本的

测试

@Test
    public void testWrite07() throws IOException {
        //1. 创建工作簿
        Workbook workbook=new XSSFWorkbook();
        //2. 创建工作表 参数：表的名称
        Sheet sheet=workbook.createSheet("joker_djの表");
        //3. 创建一个行
        Row row1=sheet.createRow(0);
        //4. 创建一个单元格
        Cell cell1 = row1.createCell(0);//第一行的第一列
        cell1.setCellValue("姓名");//设置值
        Cell cell2 = row1.createCell(1);//第一行的第二列
        cell2.setCellValue("joker_dj");//设置值

        //第二行
        Row row2=sheet.createRow(1);
        //4. 创建一个单元格
        Cell cell21 = row2.createCell(0);//第二行的第一列
        cell21.setCellValue("统计时间");//设置值
        Cell cell22 = row2.createCell(1);//第二行的第二列
        String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
        cell22.setCellValue(time);//设置值

        //生成一张表
        FileOutputStream fileOutputStream = new FileOutputStream(path + "/统计表07.xlsx");
        workbook.write(fileOutputStream);//输出文件内容
        //关闭流
        fileOutputStream.close();
        System.out.println("文件输出完毕");
    }

注意文件后缀

数据批量导入

大文件写入HSSF

缺点：最多只能处理65536行否则会抛出异常
优点：过程中写入缓存，最后一次写入磁盘，速度快

大文件写入XSSF

缺点：写数据速度非常慢，消耗内存，也会内存溢出 入100万条
优点：可以写较大的数据量

03版本批量插入

编写批量写入 65536行数据 超出就会报错

@Test
    public void testbranch03() throws IOException {

        //开始时间
        long start = System.currentTimeMillis();
        //创建一个工作簿
        Workbook workbook=new HSSFWorkbook();
        //创建一个工作表
        Sheet sheet = workbook.createSheet();
        for (int rownum = 0; rownum < 65536; rownum++) {
            Row row1 = sheet.createRow(rownum);
            for (int celnum = 0; celnum < 10; celnum++) {
                Cell cell = row1.createCell(celnum);//第一行第一列
                cell.setCellValue(celnum);
            }
        }
        System.out.println("end");
        FileOutputStream fileOutputStream = new FileOutputStream(path + "/brach统计表03.xls");
        workbook.write(fileOutputStream);
        fileOutputStream.close();
        //结束时间时间
        long end = System.currentTimeMillis();

        double begin=(end-start)/1000;
        System.out.println("执行时间"+begin);

    }

07版本批量插入

@Test
    public void testbranch04() throws IOException {

        //开始时间
        long start = System.currentTimeMillis();
        //创建一个工作簿
        Workbook workbook=new XSSFWorkbook();
        //创建一个工作表
        Sheet sheet = workbook.createSheet();
        for (int rownum = 0; rownum < 65537; rownum++) {
            Row row1 = sheet.createRow(rownum);
            for (int celnum = 0; celnum < 10; celnum++) {
                Cell cell = row1.createCell(celnum);//第一行第一列
                cell.setCellValue(celnum);
            }
        }
        System.out.println("end");
        FileOutputStream fileOutputStream = new FileOutputStream(path + "/brach统计表04.xlsx");
        workbook.write(fileOutputStream);
        fileOutputStream.close();
        //结束时间时间
        long end = System.currentTimeMillis();

        double begin=(end-start)/1000;
        System.out.println("执行时间"+begin);

    }

耗时较长，但插入的数据可以很多

升级版07 加速运行时间 但会产生临时文件
我们可以手动清除临时文件

POI读取数据

注意点 ：数据类型

String path="H:\\CSDN\\POI\\";
    @Test
    public void test01() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("H:\\CSDN\\POI\\统计表03.xls");
        Workbook workbook = new HSSFWorkbook(fileInputStream);
        Sheet sheet = workbook.getSheetAt(0);//获取第1个工作表
        Row row = sheet.getRow(0);//得到一行
        Cell cell = row.getCell(0);//获取第一列
        System.out.println(cell.getStringCellValue());
        fileInputStream.close();
    }

日期类型：

1. getDateCellValue() 日期
2. getStringCellValue() 字符串
3. getBooleanCellValue()布尔类型
   
   07版本的读取一样
   
   数据类型

@Test
    public void test03() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("H:\\CSDN\\POI\\java35班.xlsx");

        Workbook workbook = new XSSFWorkbook(fileInputStream);
        Sheet sheet = workbook.getSheetAt(0);
        Row row = sheet.getRow(0);//获取标题
        if(row!=null){//如果第一行不为空
            int cellncount = row.getPhysicalNumberOfCells();//获取第一行的第一列数据
            for (int cellnum = 0; cellnum < cellncount; cellnum++) {
                Cell cell = row.getCell(cellnum);
                if(cell!=null){
                    int cellType = cell.getCellType();
                    String stringCellValue = cell.getStringCellValue();
                    System.out.print(stringCellValue+"|");
                }
            }
            System.out.println();
        }
        //获取表中的内容
        int rowcount = sheet.getPhysicalNumberOfRows();
        for (int rownum = 1; rownum < rowcount; rownum++) {//获取行的数据
            Row rowData = sheet.getRow(rownum);
            if(rowData!=null){
                //读取列
                int cellcount = row.getPhysicalNumberOfCells();
                for (int celnum = 0; celnum < cellcount; celnum++) {
//                    System.out.print("【"+rownum+1+"】"+(celnum+1));
                    Cell cell = rowData.getCell(celnum);
                    /*判断数据类型*/
                    if(cell!=null){
                        int cellType = cell.getCellType();
                        String cellValue="";
                        switch (cellType){
                            case HSSFCell.CELL_TYPE_STRING://string类型
                                //System.out.println("【String】");
                                cellValue=cell.getStringCellValue();
                                break;
                            case HSSFCell.CELL_TYPE_BOOLEAN://布尔类型
                              //  System.out.println("【boolean】");
                                cellValue=String.valueOf(cell.getBooleanCellValue());
                                break;
                            case HSSFCell.CELL_TYPE_NUMERIC: //数字和日期类型
                                System.out.println("【NUMBER】");
                                if(HSSFDateUtil.isCellDateFormatted(cell)){
                                  //  System.out.println("【日期】");
                                    Date date=cell.getDateCellValue();
                                    cellValue=new DateTime(date).toString("yyy-MM-dd");
                                }else{
                                 //   System.out.println("【转换为字符串输出】");
                                    cell.setCellType(HSSFCell.CELL_TYPE_STRING);
                                    cellValue=cell.toString();
                                }
                            case HSSFCell.CELL_TYPE_ERROR://布尔类型
                              //  System.out.println("【数据类型错误】");
                                cellValue=String.valueOf(cell.getErrorCellValue());
                                break;
                        }
                        System.out.print(cellValue+"\n");
                    }
                }
            }

        }

        fileInputStream.close();
    }

计算公式

//计算公式
    @Test
    public void test04() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("H:\\CSDN\\POI\\统计表07.xlsx");
        Workbook workbook = new XSSFWorkbook(fileInputStream);
        Sheet sheet = workbook.getSheetAt(0);//获取第1个工作表
        Row row = sheet.getRow(4);//得到一行
        Cell cell = row.getCell(0);
        //拿到计算公式
        FormulaEvaluator formulaEvaluator = new XSSFFormulaEvaluator((XSSFWorkbook) workbook);
        //拿到单元格内容
        int cellType = cell.getCellType();
        switch (cellType){
            case Cell.CELL_TYPE_FORMULA://公式
                String cellFormula = cell.getCellFormula();
                System.out.println(cellFormula);//输出公式
                //计算
                CellValue evaluate = formulaEvaluator.evaluate(cell);
                String cellValue = evaluate.formatAsString();
                System.out.println(cellValue);
        }
        fileInputStream.close();
    }

easyexcel操作

写入数据

1. 导入依赖
   

<dependencies>
        <!--xls 03-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.9</version>
        </dependency>
        <!--xls 07-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.9</version>
        </dependency>
        <!--日期格式化工具-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.5</version>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

1. 编写实体类
   

@Data
public class demoData {
    @ExcelProperty("字符串标题")
    private String string;
    @ExcelProperty("日期标题")
    private Date date;
    @ExcelProperty("数字标题")
    private Double doubleData;
    /**
     * 忽略这个字段
     */
    @ExcelIgnore
    private String ignore;
}

效果

public class Testwrite {
    
    private List<demoData> data(){
        List<demoData> data=new ArrayList<demoData>();
        for (int i = 0; i < 10; i++) {
            demoData demoData = new demoData();
            demoData.setString("字符串"+i);
            demoData.setDate(new Date());
            demoData.setDoubleData(0.56);
            data.add(demoData);
        }
        return data;
    }
    //引入easyexcel
    /**
     * 最简单的写
     * <p>1. 创建excel对应的实体对象 参照{@link demoData}
     * <p>2. 直接写即可
     */
    @Test
    public void simpleWrite() {
        // 写法1
        String fileName ="H:\\CSDN\\easyexcel\\src\\main\\java\\test\\easyexcel.xlsx";
        // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        // 如果这里想使用03 则 传入excelType参数即可
        EasyExcel.write(fileName, demoData.class).sheet("模板").doWrite(data());
    }
}

文档链接：https://www.yuque.com/easyexcel/doc/write

读取数据

1. 编写监听器

// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
public class DemoDataListener extends AnalysisEventListener<DemoData> {
    private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
    /**
     * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 5;
    List<DemoData> list = new ArrayList<DemoData>();
    /**
     * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
     */
    private DemoDAO demoDAO;
    
    public DemoDataListener() {
        // 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
        demoDAO = new DemoDAO();
    }
    /**
     * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     *
     * @param demoDAO
     */
    public DemoDataListener(DemoDAO demoDAO) {
        this.demoDAO = demoDAO;
    }
    /**
     * 这个每一条数据解析都会来调用
     *
     * @param data
     *            one row value. Is is same as {@link AnalysisContext#readRowHolder()}
     * @param context
     */
    @Override
    public void invoke(DemoData data, AnalysisContext context) {
        System.out.println(JSON.toJSONString(data));
        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
        list.add(data);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (list.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            list.clear();
        }
    }



    /**
     * 所有数据解析完成了 都会来调用
     *
     * @param context
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();//保存数据库
        LOGGER.info("所有数据解析完成！");
    }
    /**
     * 加上存储数据库
     */
    private void saveData() {
        LOGGER.info("{}条数据，开始存储数据库！", list.size());
        demoDAO.save(list);
        LOGGER.info("存储数据库成功！");
    }
}

1. 编写dao层 可不写 用来持久化操作

/**
 * 假设这个是你的DAO存储。当然还要这个类让spring管理，当然你不用需要存储，也不需要这个类。
 **/
public class DemoDAO {
    public void save(List<DemoData> list) {
        // 如果是mybatis,尽量别直接调用多次insert,自己写一个mapper里面新增一个方法batchInsert,所有数据一次性插入
    }
}

1. 测试读取
   

public class TestRead {
    /**
     * 最简单的读
     * <p>1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
     * <p>3. 直接读即可
     */
    @Test
    public void simpleRead() {
        // 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
        // 写法1：
        String fileName ="H:\\CSDN\\easyexcel\\src\\main\\java\\test\\easyexcel.xlsx";
        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
        EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
    }
}

效果