javaEasyExcelexcel_0">java：EasyExcel使用（一）读excel

1 前言

EasyExcel相比于传统使用poi进行excel文件读写，编程使用操作上更加方便快捷，且对于内存溢出进行了优化处理。本文是EasyExcel读excel操作。

Java解析、生成Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。

easyexcel重写了poi对07版Excel的解析，一个3M的excel用POI sax解析依然需要100M左右内存，改用easyexcel可以降低到几M，并且再大的excel也不会出现内存溢出；03版依赖POI的sax模式，在上层做了模型转换的封装，让使用者更加简单方便。

EasyExcel官方文档：

java">https://easyexcel.opensource.alibaba.com/

进入maven.org，自动跳转如下进行maven仓库查询：

java">https://central.sonatype.com/?smo=true

搜索easyexcel：

pom文件添加如下依赖：

<dependency><groupId>com.alibaba</groupId><artifactId>easyexcel</artifactId><version>3.3.4</version>
</dependency>

2 使用（Excel读取）

2.1 读Excel

GoodsDto：

java">package com.xiaoxu.excel.readE;import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;import java.util.Date;/*** @author xiaoxu* @date 2024-04-26 22:32* learn_java:com.xiaoxu.excel.readE.GoodsDto*/
@Getter
@Setter
@EqualsAndHashCode
public class GoodsDto {private String name;private Date date;private long count;private Date produceDate;private double price;
}

在桌面准备的excel文件，test.xlsx：

excel读取方式一：

TestExcelRead，读取excel（JDK8.0+，不用额外写ReadListener，since: 3.0.0-beta1）：

java">package com.xiaoxu.excel.readE;import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.read.listener.PageReadListener;
import com.alibaba.fastjson.JSON;import javax.swing.filechooser.FileSystemView;
import java.io.File;
import java.text.SimpleDateFormat;/*** @author xiaoxu* @date 2024-04-27 14:53* learn_java:com.xiaoxu.excel.readE.TestExcelRead*/
public class TestExcelRead {public static void main(String[] args) {// C:\Users\****\DesktopFile homeDirectory = FileSystemView.getFileSystemView().getHomeDirectory();String fileName = "test";//  读取桌面路径excel文件String file = homeDirectory.getAbsolutePath()+ File.separator + fileName + ".xlsx";EasyExcel.read(file, GoodsDto.class,new PageReadListener<GoodsDto>(dataList -> {for (GoodsDto goodsDto : dataList) {System.out.println("读取到excel数据：" +JSON.toJSONString(goodsDto));SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");if (null != goodsDto.getDate()) {System.out.println("日期:" +sdf.format(goodsDto.getDate()));}if (null != goodsDto.getProduceDate()) {System.out.println("生产日期:" +sdf.format(goodsDto.getProduceDate()));}}})).sheet().doRead();}}

执行excel读取结果如下：

java">读取到excel数据：
{"count":45,"date":1709099280000,
"name":"苹果","price":1.65,"produceDate":15278342400000}
日期:2024-02-28 13:48:00.000
生产日期:2454-02-25 00:00:00.000读取到excel数据：{"count":13,"date":1713611400000,
"name":"梨子","price":2.4,"produceDate":15278515200000}
日期:2024-04-20 19:10:00.000
生产日期:2454-02-27 00:00:00.000读取到excel数据：{"count":0,"name":"菠萝","price":9.9}

日期转换说明，需要按照excel的日期格式来写，

上述结果表明，如果是引用类型，那么excel的cell值为null时，不会为实体类赋值；如果实体类是primitive类型数据，同时excel的cell值为null时，会将null转换成该primitive的默认值，比如实体类的count属性为long时，默认值就是0，所以也会赋值（因为包装类的值为null时，直接转换成primitive类型值时，不可以为其赋值为null，必须转换成其对应的默认值，否则将会抛出异常）。

同时注意，上述的实体类的字段，和excel的每一列是按顺序一一对应定义的。否则可能会抛出ExcelDataConvertException转换异常（Excel的值类型需要和实体类字段类型一一对应）。

excel读取方式二：

TestExcelRead2，读取excel（定义监听器GoodsDtoListener读取excel）：

GoodsDtoListener：

java">package com.xiaoxu.excel.readE;import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.util.ListUtils;
import com.alibaba.fastjson.JSON;import java.util.List;/*** @author xiaoxu* @date 2024-04-26 22:42* learn_java:com.xiaoxu.excel.readE.GoodsDtoListener*/
public class GoodsDtoListener implements ReadListener<GoodsDto> {/*** 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收*/private static final int BATCH_COUNT = 100;/*** 缓存数据*/private List<GoodsDto> cache = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);/*** 假设这个是一个DAO，* 当然有业务逻辑这个也可以是一个service。* 当然如果不用存储这个对象没用。*/private GoodsDAO goodsDAO;public GoodsDtoListener() {//  这里是demo，所以随便new一个。//  实际使用如果到了spring,请使用下面的有参构造函数this.goodsDAO = new GoodsDAO();}public GoodsDtoListener(GoodsDAO goodsDAO) {//  如果使用了spring,请使用这个构造方法。//  每次创建Listener的时候需要把spring管理的类传进来this.goodsDAO = goodsDAO;}/*** @param goodsDto        one row value.*                        Is is same*                        as {@link AnalysisContext#readRowHolder()}* @param analysisContext 这个每一条数据解析都会来调用*/@Overridepublic void invoke(GoodsDto goodsDto, AnalysisContext analysisContext) {System.out.println(String.format("解析到数据: %s.", JSON.toJSONString(goodsDto)));cache.add(goodsDto);// 达到BATCH_COUNT了，需要去存储一次数据库，// 防止数据几万条数据在内存，容易OOMif (cache.size() >= BATCH_COUNT) {saveData();// cache置为空List，方便gc workcache = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);}}private void saveData() {System.out.println("开始存储数据数数据：" + cache.size());goodsDAO.save(cache);}/*** @param analysisContext 所有数据处理完，调用这里*/@Overridepublic void doAfterAllAnalysed(AnalysisContext analysisContext) {//  这里也要保存数据，//  确保最后遗留的数据也存储到数据库System.out.println("最终数据存储:");saveData();System.out.println("所有数据解析完成!");}}

GoodsDAO ：

java">public class GoodsDAO {public void save(List<GoodsDto> goodsDtoList) {// 如果是mybatis,尽量别直接调用多次insert,// 自己写一个mapper里面新增一个方法batchInsert,// 所有数据一次性插入// batchInsert的插入性能更好System.out.println("存储数据成功~");}}

TestExcelRead2：

java">package com.xiaoxu.excel.readE;import com.alibaba.excel.EasyExcel;import javax.swing.filechooser.FileSystemView;
import java.io.File;/*** @author xiaoxu* @date 2024-04-27 16:37* learn_java:com.xiaoxu.excel.readE.TestExcelRead2*/
public class TestExcelRead2 {public static void main(String[] args) {// C:\Users\****\DesktopFile homeDirectory = FileSystemView.getFileSystemView().getHomeDirectory();String fileName = "test";//  读取桌面路径excel文件String file = homeDirectory.getAbsolutePath()+ File.separator + fileName + ".xlsx";//   有个很重要的点 GoodsDtoListener 不能被spring管理，//   要每次读取excel都要new,然后里面用到spring可以构造方法传进去//   excel有多个Sheet，可以通过 .sheet("Sheet1")指定sheet名称//   或者可以通过.sheet(0)指定读取第1个sheet   //   如果sheet名称不存在，那么不会报错，也不会读取到数据EasyExcel.read(file, GoodsDto.class, new GoodsDtoListener()).sheet("Sheet1").doRead();}}

执行结果如下：

java">解析到数据: {"count":45,"date":1709099280000,
"name":"苹果","price":1.65,"produceDate":1746545644800000}.
解析到数据: {"count":13,"date":1713611400000,
"name":"梨子","price":2.4,"produceDate":1746563788800000}.
解析到数据: {"count":0,"name":"菠萝","price":9.9}.
最终数据存储:
开始存储数据数数据：3
存储数据成功~
所有数据解析完成!

注意：excel文件有多个sheet时，.sheet()表示读取第1个sheet的内容。若需要指定sheet名称读取，则使用.sheet(“Sheet1”)即可指定名称为Sheet1的sheet进行读取，若不知道sheet名称，那么可以通过.sheet(0)读取第1个sheet，.sheet(1)读取第2个sheet等等的方式来进行读取，下标从0开始。如果sheet的名称不存在，或者sheet的索引下标不存在（比如总共只有3个sheet，但是读取为.sheet(3)第4个sheet）时，不会抛出异常，只是无法读取到对应数据。并且EasyExcel读取sheet的数据时，表头不会进入Listener回调中，而是从第二行的内容数据开始进入回调。

excel读取方式三：

TestExcelRead3，读取excel（通过ExcelReader、ReadSheet读取excel文件）：

java">package com.xiaoxu.excel.readE;import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.read.metadata.ReadSheet;import javax.swing.filechooser.FileSystemView;
import java.io.File;/*** @author xiaoxu* @date 2024-04-27 19:32* learn_java:com.xiaoxu.excel.readE.TestExcelRead3*/
public class TestExcelRead3 {public static void main(String[] args) {// C:\Users\****\DesktopFile homeDirectory = FileSystemView.getFileSystemView().getHomeDirectory();String fileName = "test";//  读取桌面路径excel文件String file = homeDirectory.getAbsolutePath()+ File.separator + fileName + ".xlsx";// 一个文件一个readertry (ExcelReader excelReader = EasyExcel.read(file, GoodsDto.class, new GoodsDtoListener()).build()) {// 构建一个sheet 这里可以指定名字或者noReadSheet readSheet = EasyExcel.readSheet(0).build();// 读取一个sheetexcelReader.read(readSheet);}}}

读取结果同读取方式二一致。

2.2 指定列的下标或者列名

前面提到了，实体类的字段必须按照顺序和excel的列一一对应，否则可能出现转换异常或者赋值与实际字段不匹配的情况。但是这种情况也有解决方式，即使用EasyExcel提供的@ExcelProperty注解。

GoodsDtoProperty：

java">package com.xiaoxu.excel.cols;import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;import java.util.Date;/*** @author xiaoxu* @date 2024-04-27 20:36* learn_java:com.xiaoxu.excel.cols.GoodsDtoPropertty*/
@Getter
@Setter
@EqualsAndHashCode
public class GoodsDtoProperty {//  注解的默认值是value，这里表示excel的表头的列名称@ExcelProperty("售卖日期")private Date date;@ExcelProperty(index = 99)private long count;private Date produceDate;// index表示读取第几列，0表示第一列，1表示第二列...// 这里price属性是实体类第四个属性，没有 @ExcelProperty表示和第4列对应// 这里表示和excel的第5列对应@ExcelProperty(index = 4)private double price;@ExcelProperty(value = "名称")private String name;
}

excel数据如下：

TestExcelReadProp：

java">package com.xiaoxu.excel.cols;import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.read.listener.PageReadListener;
import com.alibaba.fastjson.JSON;import javax.swing.filechooser.FileSystemView;
import java.io.File;
import java.text.SimpleDateFormat;/*** @author xiaoxu* @date 2024-04-27 20:46* learn_java:com.xiaoxu.excel.cols.TestExcelReadProp*/
public class TestExcelReadProp {public static void main(String[] args) {// C:\Users\****\DesktopFile homeDirectory = FileSystemView.getFileSystemView().getHomeDirectory();String fileName = "test";//  读取桌面路径excel文件String file = homeDirectory.getAbsolutePath()+ File.separator + fileName + ".xlsx";EasyExcel.read(file, GoodsDtoProperty.class,new PageReadListener<GoodsDtoProperty>(dataList -> {for (GoodsDtoProperty goodsDtoProp : dataList) {System.out.println("读取到excel数据：" +JSON.toJSONString(goodsDtoProp));SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");if (null != goodsDtoProp.getDate()) {System.out.println("日期:" +sdf.format(goodsDtoProp.getDate()));}if (null != goodsDtoProp.getProduceDate()) {System.out.println("生产日期:" +sdf.format(goodsDtoProp.getProduceDate()));}}})).sheet().doRead();}}

执行结果：

javascript">读取到excel数据：{"count":0,"name":"苹果",
"price":1.65,"produceDate":1709099280000}
生产日期:2024-02-28 13:48:00.000读取到excel数据：{"count":0,"name":"梨子",
"price":2.4,"produceDate":1713611400000}
生产日期:2024-04-20 19:10:00.000读取到excel数据：{"count":0,"name":"菠萝","price":9.9}

上述表明，如果实体类中使用了@ExcelProperty注解，那么最好是全部属性都加上，这样方便和excel需要的属性列一一对应，否则可能出现部分值胡乱匹配excel列值的情况。同时，如果注解的value值随意填写，即excel的匹配列名不存在，或者index超越索引上限，都不会报错。同时index索引也是从0开始，0表示excel的第1列，1表示excel的第2列，以此类推。

2.3 读多个sheet

2.3.1 读取全部sheet

准备excel文件中存在多个Sheet，文件为test3.xlsx：

Sheet1：

Sheet2：

提取读取桌面文件工具类：

java">package com.xiaoxu.excel;import javax.swing.filechooser.FileSystemView;
import java.io.File;/*** @author xiaoxu* @date 2024-04-27 22:00* learn_java:com.xiaoxu.excel.DeskTool*/
public class DeskTool {public static String getPath(String fileName) {// C:\Users\****\DesktopFile homeDirectory = FileSystemView.getFileSystemView().getHomeDirectory();//  读取桌面路径excel文件return homeDirectory.getAbsolutePath()+ File.separator + fileName + ".xlsx";}}

GoodsDtoNew：

java">package com.xiaoxu.excel.multiSht;import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;import java.util.Date;/*** @author xiaoxu* @date 2024-04-27 22:17* learn_java:com.xiaoxu.excel.multiSht.GoodsDtoNew*/
@Getter
@Setter
@EqualsAndHashCode
public class GoodsDtoNew {//  注解的默认值是value，这里表示excel的表头的列名称@ExcelProperty("日期")private Date date;@ExcelProperty("生产日期")private Date produceDate;@ExcelProperty("价格")private double price;@ExcelProperty("数量")private long count;@ExcelProperty(value = "名称")private String name;
}

GoodsDtoNewListener：

java">package com.xiaoxu.excel.multiSht;import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;/*** @author xiaoxu* @date 2024-04-27 22:20* learn_java:com.xiaoxu.excel.multiSht.GoodsDtoNewListener*/
public class GoodsDtoNewListener implements ReadListener<GoodsDtoNew> {@Overridepublic void invoke(GoodsDtoNew goodsDtoNew, AnalysisContext analysisContext) {System.out.println("扫描数据："+ JSON.toJSONString(goodsDtoNew));}@Overridepublic void doAfterAllAnalysed(AnalysisContext analysisContext) {System.out.println("所有数据解析完成!");}
}

TestExcelReadMultiSheetAll：

java">package com.xiaoxu.excel.multiSht;import com.alibaba.excel.EasyExcel;
import com.xiaoxu.excel.DeskTool;/*** @author xiaoxu* @date 2024-04-27 21:57* learn_java:com.xiaoxu.excel.multiSht.TestExcelReadMultiSheetAll*/
public class TestExcelReadMultiSheetAll {public static void main(String[] args) {String file = DeskTool.getPath("test3");// 读取全部sheet// 这里需要注意 GoodsDtoNewListener的doAfterAllAnalysed// 会在每个sheet读取完毕后调用一次。// 然后所有sheet都会往同一个GoodsDtoNewListener里面写(或者读)EasyExcel.read(file,GoodsDtoNew.class,new GoodsDtoNewListener()).doReadAll();}}

执行结果：

java">扫描数据：{"count":45,"date":1709099280000,
"name":"苹果","price":1.65,"produceDate":1746545644800000}
扫描数据：{"count":13,"date":1713611400000,
"name":"梨子","price":2.4,"produceDate":1746563788800000}
扫描数据：{"count":0,"name":"菠萝","price":9.9}
所有数据解析完成!扫描数据：{"count":45,"date":1709349480000,
"name":"水蜜桃","price":3.5,"produceDate":1746535536000000}
扫描数据：{"count":13,"date":1713805800000,
"name":"菠萝蜜","price":9.5,"produceDate":1746546508800000}
扫描数据：{"count":88,"date":1714227300000,
"name":"百香果","price":7.8,"produceDate":1746552816000000}
所有数据解析完成!所有数据解析完成!

上述表明，doReadAll()方法会处理全部的Sheet数据，且全部sheet的数据是同一个listener处理的，并且doAfterAllAnalysed()最终读取完毕的回调方法，3个sheet分别调用了3次（因为上述的excel文件还有一个空的Sheet3）。

2.3.2 读取部分sheet

准备excel文件中存在多个Sheet，多个Sheet结构不同（对应不同监听器），文件为test2.xlsx：

Sheet1：

Sheet2：

MerchantDto：

java">package com.xiaoxu.excel.multiSht;import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;/*** @author xiaoxu* @date 2024-04-28 8:23* learn_java:com.xiaoxu.excel.multiSht.MerchantDto*/
@Getter
@Setter
@EqualsAndHashCode
public class MerchantDto {@ExcelProperty("商户名称")private String merchantName;@ExcelProperty("商户库存")private long merchantInventory;}

MerchantDtoListener：

java">package com.xiaoxu.excel.multiSht;import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;/*** @author xiaoxu* @date 2024-04-28 8:25* learn_java:com.xiaoxu.excel.multiSht.MerchantDtoListener*/
public class MerchantDtoListener implements ReadListener<MerchantDto> {@Overridepublic void invoke(MerchantDto merchantDto, AnalysisContext analysisContext) {System.out.println("扫描商户数据："+ JSON.toJSONString(merchantDto));}@Overridepublic void doAfterAllAnalysed(AnalysisContext analysisContext) {System.out.println("商户所有数据解析完成!");}
}

TestExcelReadMultiSheet：

java">package com.xiaoxu.excel.multiSht;import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.read.metadata.ReadSheet;
import com.xiaoxu.excel.DeskTool;/*** @author xiaoxu* @date 2024-04-27 21:56* learn_java:com.xiaoxu.excel.multiSht.TestExcelReadMultiSheet*/
public class TestExcelReadMultiSheet {public static void main(String[] args) {String file = DeskTool.getPath("test2");// 一个文件一个readertry (ExcelReader excelReader = EasyExcel.read(file).build()) {//  可以注册同样的head和Listener 自己使用功能使用不同的Listener// 构建一个sheet 这里可以指定名字或者noReadSheet readSheet = EasyExcel.readSheet(0).head(GoodsDtoNew.class).registerReadListener(new GoodsDtoNewListener()).build();ReadSheet readSheet2 = EasyExcel.readSheet(1).head(MerchantDto.class).registerReadListener(new MerchantDtoListener()).build();// 这里注意 一定要把sheet1 sheet2 一起传进去，// 不然有个问题就是03版的excel 会读取多次，浪费性能excelReader.read(readSheet, readSheet2);}}}

执行结果：

java">扫描数据：{"count":45,"date":1709099280000,
"name":"苹果","price":1.65,"produceDate":1746545644800000}
扫描数据：{"count":13,"date":1713611400000,
"name":"梨子","price":2.4,"produceDate":1746563788800000}
扫描数据：{"count":0,"name":"菠萝","price":9.9}
所有数据解析完成!扫描商户数据：{"merchantInventory":150,"merchantName":"天天水果"}
扫描商户数据：{"merchantInventory":500,"merchantName":"只爱水果"}
商户所有数据解析完成!

2.4 日期、数字或者自定义格式转换

test4.xlsx：

ConverterData：

java">package com.xiaoxu.excel.format;import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.format.DateTimeFormat;
import com.alibaba.excel.annotation.format.NumberFormat;
import lombok.Getter;
import lombok.Setter;/*** @author xiaoxu* @date 2024-04-29 20:01* learn_java:com.xiaoxu.excel.format.ConverterData*/
@Setter
@Getter
public class ConverterData {/*** 定义 转换器*/@ExcelProperty(value = "信息",converter = CustomStringConverter.class)private String message;/*** 这里用string 去接日期才能格式化。接收年月日格式*/@DateTimeFormat("yyyy年MM月dd日HH时mm分ss秒SSS毫秒")@ExcelProperty("日期")private String date;/*** 接收百分比的数字*/@NumberFormat("#.##%")@ExcelProperty("价格")private String price;}

CustomStringConverter，日期、数字或者自定义格式转换：

java">package com.xiaoxu.excel.format;import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.converters.ReadConverterContext;
import com.alibaba.excel.converters.WriteConverterContext;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.data.WriteCellData;/*** @author xiaoxu* @date 2024-04-29 20:05* learn_java:com.xiaoxu.excel.format.CustomStringConverter*/
public class CustomStringConverter implements Converter<String> {@Overridepublic Class<?> supportJavaTypeKey() {return String.class;}@Overridepublic CellDataTypeEnum supportExcelTypeKey() {return CellDataTypeEnum.STRING;}/*** @param context* @return* @throws Exception 读的时候调用*/@Overridepublic String convertToJavaData(ReadConverterContext<?> context) throws Exception {String str = context.getReadCellData().getStringValue();char[] chars = str.toCharArray();int left = 0;int right = chars.length - 1;while (left < right) {char temp = chars[left];chars[left] = chars[right];chars[right] = temp;left++;right--;}return new String(chars);}/*** @param context* @return* @throws Exception 写的时候调用，这里不涉及写*/@Overridepublic WriteCellData<?> convertToExcelData(WriteConverterContext<String> context)throws Exception {return new WriteCellData<>(context.getValue());}
}

TestExcelConverter：

java">public class TestExcelConverter {public static void main(String[] args) {String file = DeskTool.getPath("test4");EasyExcel.read(file, ConverterData.class,// 这里注意 我们也可以registerConverter来指定自定义转换器， // 但是这个转换变成全局了，所有java为string,// excel为string的都会用这个转换器。// 如果就想单个字段使用请使用@ExcelProperty 指定converter// .registerConverter(new CustomStringStringConverter())new PageReadListener<ConverterData>((list) -> {for (ConverterData c : list) {System.out.println("读取到excel数据：" +JSON.toJSONString(c));}})).sheet().doRead();}
}

执行结果：

java">读取到excel数据：{"date":"2024年02月28日13时48分00秒000毫秒",
"message":"ebab好你","price":"980%"}
读取到excel数据：{"date":"2024年04月08日11时20分00秒000毫秒",
"message":"EBABEFAC","price":"570%"}

上述convertToJavaData对String类型数据，进行字符串反转。

上述字符串反转，还可以使用下面的方式，效果一致：

java">String str = context.getReadCellData().getStringValue();
char[] chars = str.toCharArray();
int left = 0;
int right = chars.length - 1;
while (left < right) {chars[left] ^= chars[right];chars[right] ^= chars[left];chars[left] ^= chars[right];left++;right--;
}
return new String(chars);

2.5 多行头

test5.xlsx：

TestMultiHead：

java">public class TestMultiHead {public static void main(String[] args) {String file = DeskTool.getPath("test5");EasyExcel.read(file, ConverterData.class,new PageReadListener<ConverterData>((list) -> {for (ConverterData c : list) {System.out.println("读取到excel数据：" +JSON.toJSONString(c));}})).sheet().doRead();}}

执行结果：

java">读取到excel数据：{"date":"日期","message":"息信","price":"价格"}
读取到excel数据：{"date":"日期","message":"息信","price":"价格"}
读取到excel数据：{"date":"2024年02月28日13时48分00秒000毫秒",
"message":"ebab好你","price":"980%"}
读取到excel数据：{"date":"2024年04月08日11时20分00秒000毫秒",
"message":"EBABEFAC","price":"570%"}

默认就是如下的.headRowNumber(1)，表头一般是1行：

java">String file = DeskTool.getPath("test5");
EasyExcel.read(file, ConverterData.class,new PageReadListener<ConverterData>((list) -> {for (ConverterData c : list) {System.out.println("读取到excel数据：" +JSON.toJSONString(c));}})).sheet().headRowNumber(1).doRead();

如果上述有3行表头，我们希望都去掉，那么修改如下：

java">String file = DeskTool.getPath("test5");
EasyExcel.read(file, ConverterData.class,new PageReadListener<ConverterData>((list) -> {for (ConverterData c : list) {System.out.println("读取到excel数据：" +JSON.toJSONString(c));}})).sheet().headRowNumber(3).doRead();

3行表头场景，希望都去掉表头，使用.headRowNumber(3)即可，执行结果如下：

java">读取到excel数据：{"date":"2024年02月28日13时48分00秒000毫秒",
"message":"ebab好你","price":"980%"}
读取到excel数据：{"date":"2024年04月08日11时20分00秒000毫秒",
"message":"EBABEFAC","price":"570%"}

2.6 同步的返回

test6.xlsx：

PeopleDto：

java">@Setter
@Getter
public class PeopleDto {@ExcelProperty("名称")private String name;@ExcelProperty("年龄")private int age;}

TestSyncRead：

java">String file = DeskTool.getPath("test6");//  synchronous，同步的返回，不推荐使用，
//  如果数据量大会把数据放到内存里面
List<PeopleDto> peopleDtos = EasyExcel.read(file).head(PeopleDto.class).sheet().doReadSync();
for (PeopleDto p : peopleDtos) {System.out.println("读取到excel数据：" +JSON.toJSONString(p));
}
//  这里 也可以不指定class，返回一个list，
//  然后读取第一个sheet 同步读取会自动finish
List<Map<Integer, String>> listMap = EasyExcel.read(file).sheet().doReadSync();
for (Map<Integer, String> data : listMap) {// 返回每条数据的键值对 表示所在的列 和所在列的值System.out.println("读取到数据:" + JSON.toJSONString(data));
}

执行结果：

java">读取到excel数据：{"age":66,"name":"小徐"}
读取到excel数据：{"age":22,"name":"小李"}读取到数据:{0:"小徐",1:"66"}
读取到数据:{0:"小李",1:"22"}

2.7 读取表头数据

监听器重写invokeHeadMap方法即可：

PeopleDtoListener监听器：

java">import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.util.ConverterUtils;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;import java.util.List;
import java.util.Map;/*** @author xiaoxu* @date 2024-04-30* java_demo:com.xiaoxu.test.excel.sync.PeopleDtoListener*/
public class PeopleDtoListener implements ReadListener<PeopleDto> {List<PeopleDto> peopleDtos = Lists.newArrayListWithCapacity(2);@Overridepublic void invoke(PeopleDto peopleDto, AnalysisContext analysisContext) {peopleDtos.add(peopleDto);}@Overridepublic void doAfterAllAnalysed(AnalysisContext analysisContext) {}@Overridepublic void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {Map<Integer, String> head = ConverterUtils.convertToStringMap(headMap, context);System.out.println("读取到表头数据:" + JSON.toJSONString(head));// 如果想转成成 Map<Integer,String>// 方案1： 不要implements ReadListener 而是 extends AnalysisEventListener// 方案2： 调用 ConverterUtils.convertToStringMap(headMap, context) 自动会转换}
}

excel的head表头数据处理：

java">String file = DeskTool.getPath("test6");//  synchronous，同步的返回，不推荐使用，
//  如果数据量大会把数据放到内存里面
//  表头数据读取      
List<PeopleDto> peopleDtos = EasyExcel.read(file).head(PeopleDto.class).registerReadListener(new PeopleDtoListener()).sheet().doReadSync();
for (PeopleDto p : peopleDtos) {System.out.println("读取到excel数据：" +JSON.toJSONString(p));
}

执行结果：

java">读取到表头数据:{0:"名称",1:"年龄"}
读取到excel数据：{"age":66,"name":"小徐"}
读取到excel数据：{"age":22,"name":"小李"}

2.8 额外信息（批注、超链接、合并单元格信息读取）

since 2.0.0-beta1

对象：

java">@Getter
@Setter
@EqualsAndHashCode
public class DemoExtraData {private String row1;private String row2;
}

监听器：

java">@Slf4j
public class DemoExtraListener implements ReadListener<DemoExtraData> {@Overridepublic void invoke(DemoExtraData data, AnalysisContext context) {}@Overridepublic void doAfterAllAnalysed(AnalysisContext context) {}@Overridepublic void extra(CellExtra extra, AnalysisContext context) {log.info("读取到了一条额外信息:{}", JSON.toJSONString(extra));switch (extra.getType()) {case COMMENT:log.info("额外信息是批注,在rowIndex:{},columnIndex;{},内容是:{}", extra.getRowIndex(), extra.getColumnIndex(),extra.getText());break;case HYPERLINK:if ("Sheet1!A1".equals(extra.getText())) {log.info("额外信息是超链接,在rowIndex:{},columnIndex;{},内容是:{}", extra.getRowIndex(),extra.getColumnIndex(), extra.getText());} else if ("Sheet2!A1".equals(extra.getText())) {log.info("额外信息是超链接,而且覆盖了一个区间,在firstRowIndex:{},firstColumnIndex;{},lastRowIndex:{},lastColumnIndex:{},"+ "内容是:{}",extra.getFirstRowIndex(), extra.getFirstColumnIndex(), extra.getLastRowIndex(),extra.getLastColumnIndex(), extra.getText());} else {Assert.fail("Unknown hyperlink!");}break;case MERGE:log.info("额外信息是超链接,而且覆盖了一个区间,在firstRowIndex:{},firstColumnIndex;{},lastRowIndex:{},lastColumnIndex:{}",extra.getFirstRowIndex(), extra.getFirstColumnIndex(), extra.getLastRowIndex(),extra.getLastColumnIndex());break;default:}}
}

java">/*** 额外信息（批注、超链接、合并单元格信息读取）* <p>* 由于是流式读取，没法在读取到单元格数据的时候直接读取到额外信息，所以只能最后通知哪些单元格有哪些额外信息** <p>* 1. 创建excel对应的实体对象 参照{@link DemoExtraData}* <p>* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoExtraListener}* <p>* 3. 直接读即可** @since 2.2.0-beat1*/
@Test
public void extraRead() {String fileName = TestFileUtil.getPath() + "demo" + File.separator + "extra.xlsx";// 这里 需要指定读用哪个class去读，然后读取第一个sheetEasyExcel.read(fileName, DemoExtraData.class, new DemoExtraListener())// 需要读取批注 默认不读取.extraRead(CellExtraTypeEnum.COMMENT)// 需要读取超链接 默认不读取.extraRead(CellExtraTypeEnum.HYPERLINK)// 需要读取合并单元格信息 默认不读取.extraRead(CellExtraTypeEnum.MERGE).sheet().doRead();
}

test7.xlsx：

ConverterData：

java">@Setter
@Getter
public class ConverterData {/*** 定义 转换器*/@ExcelProperty(value = "信息",converter = CustomStringConverter.class)private String message;/*** 这里用string 去接日期才能格式化。接收年月日格式*/@DateTimeFormat("yyyy年MM月dd日HH时mm分ss秒SSS毫秒")@ExcelProperty("日期")private String date;/*** 接收百分比的数字*/@NumberFormat("#.##%")@ExcelProperty("价格")private String price;}

MergeDataListener：

java">package com.xiaoxu.excel.merge;import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.metadata.CellExtra;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;
import com.xiaoxu.excel.format.ConverterData;import java.text.MessageFormat;/*** @author xiaoxu* @date 2024-04-30 22:13* learn_java:com.xiaoxu.excel.merge.MergeDataListener*/
public class MergeDataListener implements ReadListener<ConverterData> {@Overridepublic void invoke(ConverterData converterData, AnalysisContext analysisContext) {System.out.println("读取正常数据:" +JSON.toJSONString(converterData));}@Overridepublic void doAfterAllAnalysed(AnalysisContext analysisContext) {}@Overridepublic void extra(CellExtra extra, AnalysisContext context) {System.out.println("读取额外数据:" +JSON.toJSONString(extra));switch (extra.getType()) {case MERGE:System.out.println(MessageFormat.format("额外信息是合并单元格," +"覆盖区间:firstRowIndex:{0}," +"firstColumnIndex:{1}," +"lastRowIndex:{2},lastColumnIndex:{3}.",extra.getFirstRowIndex(),extra.getFirstColumnIndex(),extra.getLastRowIndex(),extra.getLastColumnIndex()));}}
}

TestMerge：

java">// 这种写法只会输出正常读取的数据，而不会输出合并的单元格等数据
// 批注、超链接、合并单元格默认不读取
//        EasyExcel.read(file).head(ConverterData.class)
//                .registerReadListener(new MergeDataListener())
//                .sheet().headRowNumber(1).doRead();
EasyExcel.read(file).head(ConverterData.class).registerReadListener(new MergeDataListener()).extraRead(CellExtraTypeEnum.MERGE).sheet().headRowNumber(1).doRead();

执行结果：

java">读取正常数据:{"date":"2024年02月28日13时48分00秒000毫秒",
"message":"ebab好你","price":"980%"}
读取正常数据:{"date":"2024年04月08日11时20分00秒000毫秒",
"message":"EBABEFAC","price":"570%"}读取额外数据:{"columnIndex":0,"firstColumnIndex":0,
"firstRowIndex":2,"lastColumnIndex":0,
"lastRowIndex":3,"rowIndex":2,"type":"MERGE"}
额外信息是合并单元格,覆盖区间:firstRowIndex:2,firstColumnIndex:0,
lastRowIndex:3,lastColumnIndex:0.

2.9 读取公式和单元格类型

test8.xlsx：

其中金额是公式生成的，是单价*数量计算出来的。

公式操作如下，在第一列数据的金额列下，输入=号，然后选中苹果的单价列，输入*表示乘，再选中苹果的数量列，按下enter即公式配置成功，下拉苹果列的金额，即可自动填充后续列的公式：

CellDataReadData：

java">package com.xiaoxu.excel.formula;import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.metadata.data.CellData;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;import java.util.Date;/*** @author xiaoxu* @date 2024-05-01 10:22* learn_java:com.xiaoxu.excel.formula.CellDataReadData*/
@Getter
@Setter
@EqualsAndHashCode
public class CellDataReadData {@ExcelProperty("品名")private CellData<String> name;@ExcelProperty("单价")private CellData<Long> price;@ExcelProperty("数量")private CellData<Long> number;@ExcelProperty("金额")private CellData<Long> money;@ExcelProperty("日期")private CellData<Date> date;
}

CellDataListener：

java">public class CellDataListener implements ReadListener<CellDataReadData> {@Overridepublic void invoke(CellDataReadData cellDataReadData, AnalysisContext analysisContext) {System.out.println("读取正常数据:" +JSON.toJSONString(cellDataReadData, true));}@Overridepublic void doAfterAllAnalysed(AnalysisContext analysisContext) {}
}

TestCellData：

java">String file = DeskTool.getPath("test8");
EasyExcel.read(file).head(CellDataReadData.class).registerReadListener(new CellDataListener()).extraRead(CellExtraTypeEnum.MERGE).sheet().headRowNumber(1).doRead();

执行结果：

java">读取正常数据:{"date":{"data":1709099280000,"dataFormatData":{"format":"yyyy-m-d h:mm","index":22},"numberValue":45350.575,"originalNumberValue":45350.575,"type":"NUMBER"},"money":{"data":24,"dataFormatData":{"format":"General","index":0},"formulaData":{"formulaValue":"B2*C2"},"numberValue":24,"originalNumberValue":24,"type":"NUMBER"},"name":{"data":"苹果","dataFormatData":{"format":"General","index":0},"stringValue":"苹果","type":"STRING"},"number":{"data":12,"dataFormatData":{"format":"General","index":0},"numberValue":12,"originalNumberValue":12,"type":"NUMBER"},"price":{"data":2,"dataFormatData":{"format":"General","index":0},"numberValue":2,"originalNumberValue":2,"type":"NUMBER"}
}
读取正常数据:{"date":{"data":1712546400000,"dataFormatData":{"format":"yyyy-m-d h:mm","index":22},"numberValue":45390.4722222222,"originalNumberValue":45390.4722222222,"type":"NUMBER"},"money":{"data":57,"dataFormatData":{"format":"General","index":0},"formulaData":{"formulaValue":"B3*C3"},"numberValue":57,"originalNumberValue":57,"type":"NUMBER"},"name":{"data":"西瓜","dataFormatData":{"format":"General","index":0},"stringValue":"西瓜","type":"STRING"},"number":{"data":19,"dataFormatData":{"format":"General","index":0},"numberValue":19,"originalNumberValue":19,"type":"NUMBER"},"price":{"data":3,"dataFormatData":{"format":"General","index":0},"numberValue":3,"originalNumberValue":3,"type":"NUMBER"}
}
读取正常数据:{"date":{"data":1714533600000,"dataFormatData":{"format":"yyyy-m-d h:mm","index":22},"numberValue":45413.4722222222,"originalNumberValue":45413.4722222222,"type":"NUMBER"},"money":{"data":84,"dataFormatData":{"format":"General","index":0},"formulaData":{"formulaValue":"B4*C4"},"numberValue":84,"originalNumberValue":84,"type":"NUMBER"},"name":{"data":"土豆","dataFormatData":{"format":"General","index":0},"stringValue":"土豆","type":"STRING"},"number":{"data":21,"dataFormatData":{"format":"General","index":0},"numberValue":21,"originalNumberValue":21,"type":"NUMBER"},"price":{"data":4,"dataFormatData":{"format":"General","index":0},"numberValue":4,"originalNumberValue":4,"type":"NUMBER"}
}

2.10 数据转换等异常处理

test9.xlsx：

数据转换等异常处理，在监听器中重写onException方法即可：

ErrorListener，在转换异常 获取其他异常下会调用本接口，抛出异常则停止读取，如果这里不抛出异常则继续读取下一行：

java">package com.xiaoxu.excel.exp;import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.exception.ExcelDataConvertException;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;/*** @author xiaoxu* @date 2024-05-01 11:07* learn_java:com.xiaoxu.excel.exp.ErrorListener*/
public class ErrorListener implements ReadListener<ErrorObj> {@Overridepublic void onException(Exception exception, AnalysisContext context) throws Exception {System.out.println("解析失败,继续下一行数据解析:"+ exception.getMessage());if (exception instanceof ExcelDataConvertException) {ExcelDataConvertException exp= (ExcelDataConvertException) exception;System.out.println(String.format("格式转换异常," +"第%s行,第%s列解析异常,数据为:%s.",exp.getRowIndex(), exp.getColumnIndex(),exp.getCellData().getStringValue()));}}@Overridepublic void invoke(ErrorObj errorObj, AnalysisContext analysisContext) {System.out.println("读取数据:" +JSON.toJSONString(errorObj, true));}@Overridepublic void doAfterAllAnalysed(AnalysisContext analysisContext) {}
}

ErrorObj：

java">@Setter
@Getter
public class ErrorObj {@ExcelProperty("数目")private long count;
}

TestErrorObj：

java">String file = DeskTool.getPath("test9");
EasyExcel.read(file).head(ErrorObj.class).registerReadListener(new ErrorListener()).sheet().headRowNumber(1).doRead();

执行结果：

java">解析失败,继续下一行数据解析:
Convert data com.alibaba.excel.metadata.data.ReadCellData@dc8f2848 to long error 
格式转换异常,第1行,第0列解析异常,数据为:苹果.
读取数据:{"count":120
}

2.11 不创建对象的读

不创建对象的场景下读取数据，可以使用Map<Integer, String>来存储读取的数据：

java">@Slf4j
public class NoModelDataListener extends AnalysisEventListener<Map<Integer, String>> {/*** 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收*/private static final int BATCH_COUNT = 5;private List<Map<Integer, String>> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);@Overridepublic void invoke(Map<Integer, String> data, AnalysisContext context) {log.info("解析到一条数据:{}", JSON.toJSONString(data));cachedDataList.add(data);if (cachedDataList.size() >= BATCH_COUNT) {saveData();cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);}}@Overridepublic void doAfterAllAnalysed(AnalysisContext context) {saveData();log.info("所有数据解析完成！");}/*** 加上存储数据库*/private void saveData() {log.info("{}条数据，开始存储数据库！", cachedDataList.size());log.info("存储数据库成功！");}
}

不创建对象读取：

java">/*** 不创建对象的读*/
@Test
public void noModelRead() {String fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";// 这里 只要，然后读取第一个sheet 同步读取会自动finishEasyExcel.read(fileName, new NoModelDataListener()).sheet().doRead();
}

2.12 web中的读

参考EasyExcel的读取文件方法，可以传入InputStream进行读取，那么可以结合Spring的web读取excel数据：

java">public static ExcelReaderBuilder read(InputStream inputStream, Class head, ReadListener readListener) {ExcelReaderBuilder excelReaderBuilder = new ExcelReaderBuilder();excelReaderBuilder.file(inputStream);if (head != null) {excelReaderBuilder.head(head);}if (readListener != null) {excelReaderBuilder.registerReadListener(readListener);}return excelReaderBuilder;
}

web读取如下：

java">/*** 文件上传* <p>* 1. 创建excel对应的实体对象 参照{@link UploadData}* <p>* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link UploadDataListener}* <p>* 3. 直接读即可*/
@PostMapping("upload")
@ResponseBody
public String upload(MultipartFile file) throws IOException {EasyExcel.read(file.getInputStream(), UploadData.class, new UploadDataListener(uploadDAO)).sheet().doRead();return "success";
}