• POI 和 EasyExcel 操作 Excel

    一、概述

            目前操作 Excel 比较流行的就是 Apache POI 和阿里巴巴的 easyExcel。

    1.1 POI 简介

            Apache POI 是用 Java 编写的免费开源的跨平台的 Java API，Apache POI 提供 API 给 Java 程序对 Microsoft Office 格式文档读和写的常用功能。POI 为 “Poor Obfuscation Implementation” 的首字母缩写，意为“简洁版的模糊实现”。其常用的结构如下：

            HSSF -- 提供读写 03 版本的 Excel 常用功能。

            XSSF -- 提供读写 07 版本的 Excel 常用功能。

            HWPF -- 提供读写 Word 格式的常用功能

            HSLF -- 提供读写 ppt 格式的常用功能。

            HDGF -- 提供读写 visio 格式的常用功能

    1.2 easyExcel 简介

            easyExcel 是阿里巴巴开源的一个 excel 处理框架，以使用简单、节省内存著称。easyExcel 能大大减少占用内存的主要原因是在解析 Excel 时没有将文件数据一次性全部加载到内存中，而是从磁盘上一行行读取数据，逐个解析。

            easyExcel 官网地址：https://github.com/alibaba/easyexcel

    1.3 xls 和 xlsx 区别

            常用的 excel 文档有两种结尾形式，分别为 xls 和 xlsx，其中以 xls 结尾的文档属于 03 版本的，它里面最多可以存储 65536 行数据。而以 xlsx 结尾的文档属于 07 版本的，它理论上可以存储无限行数据，这就是两者之前的区别。

    二、POI 常用操作

    2.1 添加 maven 依赖

    1.     <dependencies>
    2.         
    3.         <dependency>
    4.             <groupId>org.apache.poigroupId>
    5.             <artifactId>poiartifactId>
    6.             <version>3.9version>
    7.         dependency>
    8.         
    9.         <dependency>
    10.             <groupId>org.apache.poigroupId>
    11.             <artifactId>poi-ooxmlartifactId>
    12.             <version>3.9version>
    13.         dependency>
    14.         
    15.         <dependency>
    16.             <groupId>joda-timegroupId>
    17.             <artifactId>joda-timeartifactId>
    18.             <version>2.10.1version>
    19.         dependency>
    20.         
    21.         <dependency>
    22.             <groupId>junitgroupId>
    23.             <artifactId>junitartifactId>
    24.             <version>4.12version>
    25.         dependency>
    26.     dependencies>

    2.2 写入 Excel 操作

    2.2.1 一般文件写入

    2.2.1.1 03 版本
    1. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    2. import org.apache.poi.ss.usermodel.Cell;
    3. import org.apache.poi.ss.usermodel.Row;
    4. import org.apache.poi.ss.usermodel.Sheet;
    5. import org.apache.poi.ss.usermodel.Workbook;
    6. import org.joda.time.DateTime;
    7. import org.junit.Test;
    8.  
    9. import java.io.FileOutputStream;
    10.  
    11. public class ExcelWriteTest {
    12.     String PATH ="F:\\idea_home\\poi-excel\\";
    13.  
    14.     @Test
    15.     public void testWrite03() throws Exception {
    16.         // 1、创建一个工作簿
    17.         Workbook workbook = new HSSFWorkbook();
    18.         // 2、创建一个工作表
    19.         Sheet sheet = workbook.createSheet("我是 sheet1 页");
    20.         // 3、创建一行
    21.         Row row1  = sheet.createRow(0);
    22.         // 4、创建一个单元格
    23.         Cell cell11 = row1.createCell(0);
    24.         cell11.setCellValue("我是第一行第一个单元格");
    25.         Cell cell12 = row1.createCell(1);
    26.         cell12.setCellValue("我是第一行第二个单元格");
    27.  
    28.         // 第二行
    29.         Row row2  = sheet.createRow(1);
    30.         Cell cell21 = row2.createCell(0);
    31.         cell21.setCellValue("我是第二行第一个单元格");
    32.         Cell cell22 = row2.createCell(1);
    33.         String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
    34.         cell22.setCellValue(time);
    35.         // 03 版本的使用 xls 结尾
    36.         FileOutputStream fileOutputStream  = new FileOutputStream(PATH+"统计表03类型.xls");
    37.         workbook.write(fileOutputStream);
    38.         fileOutputStream.close();
    39.         System.out.println("Excel03 写入完成了");
    40.     }
    41. }

    2.2.2.2 07 版本
    1. import org.apache.poi.ss.usermodel.Cell;
    2. import org.apache.poi.ss.usermodel.Row;
    3. import org.apache.poi.ss.usermodel.Sheet;
    4. import org.apache.poi.ss.usermodel.Workbook;
    5. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    6. import org.joda.time.DateTime;
    7. import org.junit.Test;
    8.  
    9. import java.io.FileOutputStream;
    10.  
    11. public class ExcelWriteTest {
    12.     String PATH ="F:\\idea_home\\poi-excel\\";
    13.  
    14.     @Test
    15.     public void testWrite07() throws Exception {
    16.         // 1、创建一个工作簿
    17.         Workbook workbook = new XSSFWorkbook();
    18.         // 2、创建一个工作表
    19.         Sheet sheet = workbook.createSheet("我是 sheet1 页");
    20.         // 3、创建一行
    21.         Row row1  = sheet.createRow(0);
    22.         // 4、创建一个单元格
    23.         Cell cell11 = row1.createCell(0);
    24.         cell11.setCellValue("我是第一行第一个单元格");
    25.         Cell cell12 = row1.createCell(1);
    26.         cell12.setCellValue("我是第一行第二个单元格");
    27.  
    28.         // 第二行
    29.         Row row2  = sheet.createRow(1);
    30.         Cell cell21 = row2.createCell(0);
    31.         cell21.setCellValue("我是第二行第一个单元格");
    32.         Cell cell22 = row2.createCell(1);
    33.         String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
    34.         cell22.setCellValue(time);
    35.         // 07 版本的使用 xlsx 结尾
    36.         FileOutputStream fileOutputStream  = new FileOutputStream(PATH+"统计表07类型.xlsx");
    37.         workbook.write(fileOutputStream);
    38.         fileOutputStream.close();
    39.         System.out.println("Excel07 写入完成了");
    40.     }
    41. }

    2.2.2 大文件写入

    2.2.2.1 03 版本
    1. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    2. import org.apache.poi.ss.usermodel.Cell;
    3. import org.apache.poi.ss.usermodel.Row;
    4. import org.apache.poi.ss.usermodel.Sheet;
    5. import org.apache.poi.ss.usermodel.Workbook;
    6. import org.junit.Test;
    7.  
    8. import java.io.FileOutputStream;
    9.  
    10. public class ExcelWriteTest {
    11.     String PATH ="F:\\idea_home\\poi-excel\\";
    12.  
    13.     @Test
    14.     public void testWrite03BigData() throws Exception {
    15.         long begin = System.currentTimeMillis();
    16.         // 1、创建一个工作簿
    17.         Workbook workbook = new HSSFWorkbook();
    18.         // 2、创建一个工作表
    19.         Sheet sheet = workbook.createSheet();
    20.         // 3、写入数据
    21.         for(int rowNum =0;rowNum<65537;rowNum++){
    22.             Row row = sheet.createRow(rowNum);
    23.             for(int cellNum=0;cellNum<10;cellNum++){
    24.                 Cell cell = row.createCell(cellNum);
    25.                 cell.setCellValue(cellNum);
    26.             }
    27.         }
    28.         System.out.println("over");
    29.         FileOutputStream fileOutputStream  = new FileOutputStream(PATH+"统计表03大数据类型.xls");
    30.         workbook.write(fileOutputStream);
    31.         fileOutputStream.close();
    32.         long end = System.currentTimeMillis();
    33.         System.out.println((double)(end-begin)/1000);
    34.     }
    35. }

            缺点：最多只能处理 65536 行，否则会抛出异常。

            优点：写入过程中写入缓存，不操作磁盘，最后一次性写入磁盘，速度快。将 65537 改成65536 再次执行程序，结果如下，可以看到 1.692s 就完成了写入操作，速度还是很快的。

    2.2.2.2 07 版本
    1. import org.apache.poi.ss.usermodel.Cell;
    2. import org.apache.poi.ss.usermodel.Row;
    3. import org.apache.poi.ss.usermodel.Sheet;
    4. import org.apache.poi.ss.usermodel.Workbook;
    5. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    6. import org.junit.Test;
    7.  
    8. import java.io.FileOutputStream;
    9.  
    10. public class ExcelWriteTest {
    11.     String PATH ="F:\\idea_home\\poi-excel\\";
    12.     
    13.     @Test
    14.     public void testWrite07BigData() throws Exception {
    15.         long begin = System.currentTimeMillis();
    16.         // 1、创建一个工作簿
    17.         Workbook workbook = new XSSFWorkbook();
    18.         // 2、创建一个工作表
    19.         Sheet sheet = workbook.createSheet();
    20.         // 3、写入数据
    21.         for(int rowNum =0;rowNum<100000;rowNum++){
    22.             Row row = sheet.createRow(rowNum);
    23.             for(int cellNum=0;cellNum<10;cellNum++){
    24.                 Cell cell = row.createCell(cellNum);
    25.                 cell.setCellValue(cellNum);
    26.             }
    27.         }
    28.         System.out.println("over");
    29.         FileOutputStream fileOutputStream  = new FileOutputStream(PATH+"统计表07大数据类型.xlsx");
    30.         workbook.write(fileOutputStream);
    31.         fileOutputStream.close();
    32.         long end = System.currentTimeMillis();
    33.         System.out.println((double)(end-begin)/1000);
    34.     }
    35. }

            缺点：写数据时速度非常慢，非常耗内存，也会发生内存溢出，如100万条。

            优点：可以写较大的数据量，如20万条。

    2.2.2.3 07 版本优化
    1. import org.apache.poi.ss.usermodel.Cell;
    2. import org.apache.poi.ss.usermodel.Row;
    3. import org.apache.poi.ss.usermodel.Sheet;
    4. import org.apache.poi.ss.usermodel.Workbook;
    5. import org.apache.poi.xssf.streaming.SXSSFWorkbook;
    6. import org.junit.Test;
    7.  
    8. import java.io.FileOutputStream;
    9.  
    10. public class ExcelWriteTest {
    11.     String PATH ="F:\\idea_home\\poi-excel\\";
    12.  
    13.     @Test
    14.     public void testWrite07BigDataS() throws Exception {
    15.         long begin = System.currentTimeMillis();
    16.         // 1、创建一个工作簿
    17.         Workbook workbook = new SXSSFWorkbook();
    18.         // 2、创建一个工作表
    19.         Sheet sheet = workbook.createSheet();
    20.         // 3、写入数据
    21.         for(int rowNum =0;rowNum<100000;rowNum++){
    22.             Row row = sheet.createRow(rowNum);
    23.             for(int cellNum=0;cellNum<10;cellNum++){
    24.                 Cell cell = row.createCell(cellNum);
    25.                 cell.setCellValue(cellNum);
    26.             }
    27.         }
    28.         System.out.println("over");
    29.         FileOutputStream fileOutputStream  = new FileOutputStream(PATH+"统计表07大数据类型优化.xlsx");
    30.         workbook.write(fileOutputStream);
    31.         // 清除产生的临时文件
    32.         ((SXSSFWorkbook)workbook).dispose();
    33.         fileOutputStream.close();
    34.         long end = System.currentTimeMillis();
    35.         System.out.println((double)(end-begin)/1000);
    36.     }
    37. }

            优点：可以写非常大的数据量，如 100万 条甚至更多条，数据速度快，占用更少的内存。

            需要注意的是：代码在过程中会产生临时文件，需要清理临时文件。默认有 100 条记录被保存在内存中，如果超过这数量，则最前面的数据被写入临时文件。如果想自定义内存中数据的数量，可以使用 new SXSSFWorkbook(数量) 。

            SXSSFWorkbook 来至官方的解释：实现 “BigGridDemo” 策略的流式 XSSFWorkbook 版本。这允许写入非常大的文件而不会耗尽内存，因为任何时候只有可配置的行部分被保存在内存中。请注意，仍然可能会消耗大量内存，这些内存基于您正在使用的功能，例如合并区域，注释……仍然只存储在内存中，因此如果广泛使用，可能需要大量内存。

    2.3 读取 Excel 操作

    2.3.1 03 版本

    1. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    2. import org.apache.poi.ss.usermodel.*;
    3. import org.junit.Test;
    4. import java.io.FileInputStream;
    5.  
    6. public class ExcelRead {
    7.     String PATH ="F:\\idea_home\\poi-excel\\";
    8.  
    9.     @Test
    10.     public void testRead03() throws Exception {
    11.         // 1、获取文件流
    12.         FileInputStream fileInputStream = new FileInputStream(PATH+"统计表03类型.xls");
    13.         // 2、创建文件簿，使用 excel 能操作的这边都可以操作
    14.         Workbook workbook = new HSSFWorkbook(fileInputStream);
    15.         // 3、得到表
    16.         Sheet sheet = workbook.getSheetAt(0);
    17.         // 4、得到行
    18.         Row row  = sheet.getRow(0);
    19.         // 5、得到列
    20.         Cell cell = row.getCell(0);
    21.         // 读取值的时候需要注意类型，String 和数字调用的方法是不同的。
    22.         System.out.println(cell.getStringCellValue());
    23.         fileInputStream.close();
    24.     }
    25. }

    2.3.2 07 版本

    1. import org.apache.poi.ss.usermodel.*;
    2. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    3. import org.junit.Test;
    4. import java.io.FileInputStream;
    5.  
    6. public class ExcelRead {
    7.     String PATH ="F:\\idea_home\\poi-excel\\";
    8.  
    9.     @Test
    10.     public void testRead07() throws Exception {
    11.         // 1、获取文件流
    12.         FileInputStream fileInputStream = new FileInputStream(PATH+"统计表07类型.xlsx");
    13.         // 2、创建文件簿，使用 excel 能操作的这边都可以操作
    14.         Workbook workbook = new XSSFWorkbook(fileInputStream);
    15.         // 3、得到表
    16.         Sheet sheet = workbook.getSheetAt(0);
    17.         // 4、得到行
    18.         Row row  = sheet.getRow(0);
    19.         // 5、得到列
    20.         Cell cell = row.getCell(1);
    21.         // 读取值的时候需要注意类型，String 和数字调用的方法是不同的。
    22.         System.out.println(cell.getStringCellValue());
    23.         fileInputStream.close();
    24.     }
    25. }

    2.3.3 读取不同类型

            表格的内容如下所示：

            代码如下所示：

    1. import org.apache.poi.hssf.usermodel.HSSFCell;
    2. import org.apache.poi.hssf.usermodel.HSSFDateUtil;
    3. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    4. import org.apache.poi.ss.usermodel.*;
    5. import org.joda.time.DateTime;
    6. import org.junit.Test;
    7. import java.io.FileInputStream;
    8. import java.util.Date;
    9.  
    10. public class ExcelRead {
    11.     String PATH ="F:\\idea_home\\poi-excel\\";
    12.  
    13.     @Test
    14.     public void testCellType() throws Exception{
    15.         // 1、获取文件流
    16.         FileInputStream fileInputStream = new FileInputStream(PATH+"03商品信息.xls");
    17.         // 2、创建文件簿，使用 excel 能操作的这边都可以操作
    18.         Workbook workbook = new HSSFWorkbook(fileInputStream);
    19.         // 3、得到表
    20.         Sheet sheet = workbook.getSheetAt(0);
    21.         // 4、获取标题内容
    22.         Row rowTitle  = sheet.getRow(0);
    23.         if(rowTitle != null){
    24.             // 获取列的数量
    25.             int cellCount = rowTitle.getPhysicalNumberOfCells();
    26.             for(int cellNum=0;cellNum
    27.                 Cell cell = rowTitle.getCell(cellNum);
    28.                 if(cell != null){
    29.                     // 获取列的类型
    30.                     int cellType = cell.getCellType();
    31.                     // 获取具体的列名
    32.                     String cellValue = cell.getStringCellValue();
    33.                     System.out.print(cellValue+" | ");
    34.                 }
    35.             }
    36.         }
    37.         System.out.println();
    38.         // 5、获取表中的内容
    39.         // 获取有多少行的记录
    40.         int rowCount = sheet.getPhysicalNumberOfRows();
    41.         for(int rowNum=1;rowNum
    42.             // 获取第一行数据
    43.             Row rowData = sheet.getRow(rowNum);
    44.             if(rowData !=null){
    45.                 // 读取行中的列
    46.                 int cellCount = rowTitle.getPhysicalNumberOfCells();
    47.                 for(int cellNum=0;cellNum
    48.                     System.out.print("["+(rowNum+1)+"-"+(cellNum+1)+"]");
    49.  
    50.                     Cell cell = rowData.getCell(cellNum);
    51.                     // 匹配类的数据类型
    52.                     if(cell != null){
    53.                         int cellType = cell.getCellType();
    54.                         String cellValue="";
    55.                         switch(cellType){
    56.                             case HSSFCell.CELL_TYPE_STRING:   //字符串
    57.                                 System.out.print("【STRING】");
    58.                                 cellValue = cell.getStringCellValue();
    59.                                 break;
    60.                             case HSSFCell.CELL_TYPE_BOOLEAN:   //布尔
    61.                                 System.out.print("【BOOLEAN】");
    62.                                 cellValue = String.valueOf(cell.getBooleanCellValue());
    63.                                 break;
    64.                             case HSSFCell.CELL_TYPE_BLANK:   //空
    65.                                 System.out.print("【BLANK】");
    66.                                 break;
    67.                             case HSSFCell.CELL_TYPE_NUMERIC:   //数字（分为日期和普通数字）
    68.                                 System.out.print("【NUMERIC】");
    69.                                 if(HSSFDateUtil.isCellDateFormatted(cell)){ // 日期
    70.                                     System.out.print("【日期】");
    71.                                     Date date = cell.getDateCellValue();
    72.                                     cellValue = new DateTime(date).toString("yyyy-MM-dd");
    73.                                 }else{
    74.                                     // 非日期格式，转换成字符串格式
    75.                                     System.out.print("【转化为字符串输出】");
    76.                                     cell.setCellType(HSSFCell.CELL_TYPE_STRING);
    77.                                     cellValue = cell.toString();
    78.                                 }
    79.                                 break;
    80.                             case HSSFCell.CELL_TYPE_ERROR:   //字符串
    81.                                 System.out.print("【数据类型错误】");
    82.                                 break;
    83.                         }
    84.                         System.out.println(cellValue);
    85.                     }
    86.                 }
    87.             }
    88.         }
    89.         fileInputStream.close();
    90.     }
    91. }

    2.3.4 读取公式

            操作的表格内容如下所示：

            代码如下所示：

    1. import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
    2. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    3. import org.apache.poi.ss.usermodel.*;
    4. import org.junit.Test;
    5. import java.io.FileInputStream;
    6.  
    7. public class ExcelRead {
    8.     String PATH ="F:\\idea_home\\poi-excel\\";
    9.  
    10.     @Test
    11.     public void testFormula() throws Exception {
    12.         FileInputStream fileInputStream = new FileInputStream(PATH + "03求和.xls");
    13.         // 1.创建一个工作簿。使得excel能操作的，这边他也能操作。
    14.         Workbook workbook = new HSSFWorkbook(fileInputStream);
    15.         // 2.得到表。
    16.         Sheet sheet = workbook.getSheetAt(0);
    17.         Row row = sheet.getRow(6);
    18.         Cell cell = row.getCell(0);
    19.         // 拿到计算公司
    20.         FormulaEvaluator formulaEvaluator = new HSSFFormulaEvaluator((HSSFWorkbook) workbook);
    21.         // 输出单元格内容
    22.         int cellType = cell.getCellType();
    23.         switch (cellType){
    24.             case Cell.CELL_TYPE_FORMULA:
    25.                 String cellFormula = cell.getCellFormula();
    26.                 System.out.println(cellFormula);
    27.                 // 计算
    28.                 CellValue evaluate = formulaEvaluator.evaluate(cell);
    29.                 String cellValue = evaluate.formatAsString();
    30.                 System.out.println(cellValue);
    31.                 break;
    32.         }
    33.     }
    34. }

    三、EasyExcel 常用操作

    3.1 添加 maven 依赖

    1.     <dependencies>
    2.         
    3.         <dependency>
    4.             <groupId>com.alibabagroupId>
    5.             <artifactId>easyexcelartifactId>
    6.             <version>3.0.5version>
    7.         dependency>
    8.         <dependency>
    9.             <groupId>lambadagroupId>
    10.             <artifactId>lambadaartifactId>
    11.             <version>1.0.3version>
    12.         dependency>
    13.         <dependency>
    14.             <groupId>org.projectlombokgroupId>
    15.             <artifactId>lombokartifactId>
    16.             <version>RELEASEversion>
    17.             <scope>compilescope>
    18.         dependency>
    19.         
    20.         <dependency>
    21.             <groupId>junitgroupId>
    22.             <artifactId>junitartifactId>
    23.             <version>4.12version>
    24.         dependency>
    25.         <dependency>
    26.             <groupId>com.alibabagroupId>
    27.             <artifactId>fastjsonartifactId>
    28.             <version>1.2.7version>
    29.         dependency>
    30.     dependencies>

    3.2 写操作

            先模拟一个实体类，如下所示：

    1. import com.alibaba.excel.annotation.ExcelIgnore;
    2. import com.alibaba.excel.annotation.ExcelProperty;
    3. import lombok.EqualsAndHashCode;
    4. import lombok.Getter;
    5. import lombok.Setter;
    6.  
    7. import java.util.Date;
    8.  
    9. @Getter
    10. @Setter
    11. @EqualsAndHashCode
    12. public class DemoData {
    13.     @ExcelProperty("字符串标题")
    14.     private String string;
    15.     @ExcelProperty("日期标题")
    16.     private Date date;
    17.     @ExcelProperty("数字标题")
    18.     private Double doubleData;
    19.     /**
    20.      * 忽略这个字段
    21.      */
    22.     @ExcelIgnore
    23.     private String ignore;
    24. }

            然后写入文档即可，如下所示： 

    1. import com.alibaba.excel.EasyExcel;
    2. import com.alibaba.excel.util.ListUtils;
    3. import org.junit.Test;
    4.  
    5. import java.util.Date;
    6. import java.util.List;
    7.  
    8. public class TestWrite {
    9.     @Test
    10.     public void simpleWrite() {
    11.         String PATH ="F:\\idea_home\\poi-excel\\easyexcel统计表03类型.xlsx";
    12.         EasyExcel.write(PATH, DemoData.class)
    13.                 .sheet("模板")
    14.                 .doWrite(() -> {
    15.                     // 分页查询数据
    16.                     return data();
    17.                 });
    18.     }
    19.     private List data() {
    20.         List list = ListUtils.newArrayList();
    21.         for (int i = 0; i < 10; i++) {
    22.             DemoData data = new DemoData();
    23.             data.setString("字符串" + i);
    24.             data.setDate(new Date());
    25.             data.setDoubleData(0.56);
    26.             list.add(data);
    27.         }
    28.         return list;
    29.     }
    30. }

    3.3 读操作

    1. import lombok.EqualsAndHashCode;
    2. import lombok.Getter;
    3. import lombok.Setter;
    4.  
    5. import java.util.Date;
    6.  
    7. @Getter
    8. @Setter
    9. @EqualsAndHashCode
    10. public class DemoData {
    11.     private String string;
    12.     private Date date;
    13.     private Double doubleData;
    14. }
    1. import com.alibaba.excel.EasyExcel;
    2. import com.alibaba.excel.read.listener.PageReadListener;
    3. import com.alibaba.fastjson.JSON;
    4. import org.junit.Test;
    5.  
    6. public class TestRead {
    7.  
    8.     @Test
    9.     public void simpleRead() {
    10.  
    11.         String PATH ="F:\\idea_home\\poi-excel\\easyexcel统计表03类型.xlsx";
    12.         // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
    13.         // 这里每次会读取3000条数据 然后返回过来 直接调用使用数据就行
    14.         EasyExcel.read(PATH, DemoData.class, new PageReadListener(dataList -> {
    15.             for (DemoData demoData : dataList) {
    16.                 System.out.println(JSON.toJSONString(demoData));
    17.             }
    18.         })).sheet().doRead();
    19.     }
    20. }

    3.4 更多操作

            详细的文档地址：https://www.yuque.com/easyexcel/doc/easyexcel

  • 相关阅读:
    C++实践2：在c++20中为spdlog与fmt装配source_location
    第1章 现代通信网概述
    通过WinSCP实现Windows给Ubuntu（Linux）虚拟机传输数据
    nvidia-smi指令报错：Failed to initialize NVML: Driver 解决
    【Go入门】struct类型
    Centos - DHCP 服务器搭建
    vue导出功能实现
    git 的功能使用（三）
    python：neat-python遗传拓扑神经网络初步使用
    日本MF备案注册数据库-在线免费查询
  • 原文地址：https://blog.csdn.net/xhf852963/article/details/133673080