使用EasyExcel读取excel文件案例

最新推荐文章于 2024-05-01 17:58:41 发布
最新推荐文章于 2024-05-01 17:58:41 发布
阅读量3.4k 收藏 8
点赞数 2
分类专栏： Java 文章标签： excel easyexcel 数据转换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyxuefeng/article/details/109746341
版权

需求：

需要一个读excel文件中多sheet的工具类，返回List/Map型的数据；同时也可以进行反向写操作

具体步骤

1. 引入maven依赖
	   <!--excel插件-->
	   <dependency>
	       <groupId>com.alibaba</groupId>
	       <artifactId>easyexcel</artifactId>
	       <version>2.1.6</version>
	   </dependency>
	
	   <!--简化实体插件-->
	   <dependency>
	       <groupId>org.projectlombok</groupId>
	       <artifactId>lombok</artifactId>
	       <version>1.16.20</version>
	   </dependency>
	
	   <!--日志-->
	   <dependency>
	       <groupId>org.slf4j</groupId>
	       <artifactId>slf4j-api</artifactId>
	       <version>1.7.22</version>
	   </dependency>
	
	   <!--json-->
	   <dependency>
	       <groupId>com.alibaba</groupId>
	       <artifactId>fastjson</artifactId>
	       <version>1.2.58</version>
	   </dependency>
2.1 有实体类型

建立实体类，建立监听器类（通用型/实体类型）

import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;

/**
 * @author ：maple
 * @description：学生类
 * @date ：Created in 2020/11/17 16:41
 */
@Data
public class Student {
    //这个注解用于对应表头，value为表头值，index为列值
    @ExcelProperty(value = "姓名",index = 0)
    private String name;

    @ExcelProperty(value = "年龄",index = 1)
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}


import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;

/**
 * @author ：maple
 * @description：
 * @date ：Created in 2020/11/17 16:45
 */
@Data
public class Cat {
    @ExcelProperty(value = "昵称",index = 0)
    private String name;

    @ExcelProperty(value = "年龄",index = 1)
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

通用型（Object）监听器：


import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * 通用监听器
 */
public class ObjectListener extends AnalysisEventListener<Object> {
    private final static Logger LOGGER = LoggerFactory.getLogger(ObjectListener.class);

    private static final int BATCH_COUNT = 5;
	//存储最终数据
    List<Object> objectList = new ArrayList<>();
    //存储表头数据
    List<Object> headList = new ArrayList<>();
    //存储sheet名
    private String sheetName;

	//暂时存储数据
    List<Object> datas = new ArrayList<Object>();

    @Override
    public void invoke(Object o, AnalysisContext analysisContext) {
        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(o));
        //一条数据添加到暂时存储的存储结构中
        datas.add(o);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (datas.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            datas.clear();
        }
    }



    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        //获取sheetName
        sheetName = context.readSheetHolder().getSheetName();
//        LOGGER.info("所有数据解析完成！");
    }

    //获取表头
    @Override
    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
        //把表头数据加入到存储结构中
        headList.add(headMap);
    }

    /**
     * 入库
     */
    private void saveData() {
        LOGGER.info("{}条数据，开始存储数据库！", datas.size());
        //添加到返回的存储结构中，也可直接存储到数据库
        objectList.addAll(datas);
    }

    public List<Object> getDatas() {
        return datas;
    }

    public void setDatas(List<Object> datas) {
        this.datas = datas;
    }

    public List<Object> getObjectList() {
        return objectList;
    }

    public void setObjectList(List<Object> objectList) {
        this.objectList = objectList;
    }

    public String getSheetName() {
        return sheetName;
    }

    public void setSheetName(String sheetName) {
        this.sheetName = sheetName;
    }

    public List<Object> getHeadList() {
        return headList;
    }

    public void setHeadList(List<Object> headList) {
        this.headList = headList;
    }
}

实体类型监听器


import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import com.maple.entity.Student;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * 学生类专属监听器
 */
public class StudentListener extends AnalysisEventListener<Student> {
    private final static Logger LOGGER = LoggerFactory.getLogger(StudentListener.class);

    private static final int BATCH_COUNT = 5;

    List<Object> objectList = new ArrayList<>();
    List<Object> headList = new ArrayList<>();
    private String sheetName;

    List<Object> datas = new ArrayList<Object>();

    @Override
    public void invoke(Student student, AnalysisContext analysisContext) {
    	//每解析一行数据，就会调用该方法一次
        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(student));
        //一条数据添加到暂时存储的存储结构中
        datas.add(student);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (datas.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            datas.clear();
        }
    }



    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        //获取sheetName
        sheetName = context.readSheetHolder().getSheetName();
//        LOGGER.info("所有数据解析完成！");
    }

    //获取表头
    @Override
    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
        //把表头数据加入到存储结构中
        headList.add(headMap);
    }

    /**
     * 入库
     */
    private void saveData() {
        LOGGER.info("{}条数据，开始存储数据库！", datas.size());
        //添加到返回的存储结构中，也可直接存储到数据库
        objectList.addAll(datas);
    }

    public List<Object> getDatas() {
        return datas;
    }

    public void setDatas(List<Object> datas) {
        this.datas = datas;
    }

    public List<Object> getObjectList() {
        return objectList;
    }

    public void setObjectList(List<Object> objectList) {
        this.objectList = objectList;
    }

    public String getSheetName() {
        return sheetName;
    }

    public void setSheetName(String sheetName) {
        this.sheetName = sheetName;
    }

    public List<Object> getHeadList() {
        return headList;
    }

    public void setHeadList(List<Object> headList) {
        this.headList = headList;
    }
}
2.2 无实体型

只需要一个监听器

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sunyard.util.file.excel.ExcelListener;

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

/**
 * @author ：maple
 * @description：无实体模型的监听器
 */
public class NoModelListener extends AnalysisEventListener<Map<Integer,String>> {
    private final static Logger LOGGER = LoggerFactory.getLogger(ExcelListener.class);

    private static final int BATCH_COUNT = 5;

    //数据存储结构
    private List<Map<Integer,String>> lists = new ArrayList<>();
    //表头存储结构
    List<Map<Integer,String>> headList = new ArrayList<>();
    //sheet名
    private String sheetName;

    List<Map<Integer,String>> datas = new ArrayList<Map<Integer,String>>();

    @Override
    public void invoke(Map<Integer,String> o, AnalysisContext analysisContext) {
    	//每解析一行数据，就会调用该方法一次
        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(o));
        datas.add(o);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (datas.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            datas.clear();
        }
    }

    //获取表头
    @Override
    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
        headList.add(headMap);
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        //获取sheetName
        sheetName = context.readSheetHolder().getSheetName();
        saveData();
//        LOGGER.info("所有数据解析完成！");
    }

    /**
     * 入库
     */
    private void saveData() {
//        LOGGER.info("{}条数据，开始存储数据库！", datas.size());
        lists.addAll(datas);

    }

    public List<Map<Integer,String>> getDatas() {
        return datas;
    }

    public void setDatas(List<Map<Integer,String>> datas) {
        this.datas = datas;
    }

    public List<Map<Integer, String>> getLists() {
        return lists;
    }

    public void setLists(List<Map<Integer, String>> lists) {
        this.lists = lists;
    }

    public String getSheetName() {
        return sheetName;
    }

    public void setSheetName(String sheetName) {
        this.sheetName = sheetName;
    }

    public List<Map<Integer,String>> getHeadList() {
        return headList;
    }

    public void setHeadList(List<Map<Integer,String>> headList) {
        this.headList = headList;
    }
}
3. 工具类
  1. 读取工具类ReadExcelUtil，为保证工具类的通用性，不使用专属实体监听器

import com.alibaba.excel.EasyExcel;
import com.maple.listener.NoModelListener;
import com.maple.listener.ObjectListener;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 读取工具类
 */
public class ReadExcelUtil {

    /**
     * 返回Map型的实体模型数据
     * @param fileName 文件名
     * @param obj  对象反射类 xxx.Class
     * @param sheetNo sheet编号
     * @param headNum 表头行数，1表示1行
     * @return
     */
    public static Map<String, List<Object>> getMap(String fileName, Class obj, Integer sheetNo, Integer headNum){
        Map<String, List<Object>> map = new HashMap<>();
        //new监听器
        ObjectListener objectListener = new ObjectListener();
        //读取操作
        EasyExcel.read(fileName, obj, objectListener).sheet(sheetNo).headRowNumber(headNum).doRead();
        //获取读取的数据
        List<Object> objList = objectListener.getObjectList();
        //获取sheet名
        String objSheetName = objectListener.getSheetName();
        map.put(objSheetName,objList);
        return map;
    }

    //返回List型的实体模型数据
    public static List<Object> getList(String fileName,Class obj,Integer sheetNo,Integer headNum){
        ObjectListener objectListener = new ObjectListener();
        EasyExcel.read(fileName, obj, objectListener).sheet(sheetNo).headRowNumber(headNum).doRead();
        List<Object> objList = objectListener.getObjectList();
        return objList;
    }

    //返回有实体模型的表头
    public static List<Object> getHeadList(String fileName,Class obj,Integer sheetNo,Integer headNum){
        ObjectListener objectListener = new ObjectListener();
        EasyExcel.read(fileName, obj, objectListener).sheet(sheetNo).headRowNumber(headNum).doRead();
        List<Object> objList = objectListener.getHeadList();
        return objList;
    }


    //返回Map型的没有实体模型数据
    public static Map<String,List<Map<Integer, String>>> getMapNoModel(String fileName,Integer sheetNo,Integer headNum){
        Map<String,List<Map<Integer, String>>> map = new HashMap<>();
        NoModelListener noModelListener = new NoModelListener();
        EasyExcel.read(fileName, noModelListener).sheet(sheetNo).headRowNumber(headNum).doRead();
        List<Map<Integer, String>> lists = noModelListener.getLists();
        String sheetName = noModelListener.getSheetName();
        map.put(sheetName,lists);
        return map;
    }

    //返回List型的没有实体模型数据
    public static List<Map<Integer, String>> getListNoModel(String fileName,Integer sheetNo,Integer headNum){
        NoModelListener noModelListener = new NoModelListener();
        EasyExcel.read(fileName, noModelListener).sheet(sheetNo).headRowNumber(headNum).doRead();
        List<Map<Integer, String>> lists = noModelListener.getLists();
        return lists;
    }

    //返回List型的没有实体模型数据(仅有数据)
    public static List<List<Object>> getOnlyListNoModel(String fileName,Integer sheetNo,Integer headNum){
        NoModelListener noModelListener = new NoModelListener();
        EasyExcel.read(fileName, noModelListener).sheet(sheetNo).headRowNumber(headNum).doRead();
        List<Map<Integer, String>> lists = noModelListener.getLists();
        List<List<Object>> allData = new ArrayList<>();
        for (int i = 0; i < lists.size(); i++) {
            Map<Integer, String> map = lists.get(i);
            List<Object> rowData = new ArrayList<>();
            for (Map.Entry<Integer, String> entry : map.entrySet()) {
                rowData.add(entry.getValue());
            }
            allData.add(rowData);
        }
        return allData;
    }

    //返回没有实体模型的表头
    public static List<Map<Integer,String>> getHeadListNoModel(String fileName,Integer sheetNo,Integer headNum){
        NoModelListener noModelListener = new NoModelListener();
        EasyExcel.read(fileName, noModelListener).sheet(sheetNo).headRowNumber(headNum).doRead();
        List<Map<Integer, String>> lists = noModelListener.getHeadList();
        return lists;
    }

    /**
     * 返回没有实体模型的具体行的表头
     * @param fileName : 文件名
     * @param sheetNo : sheet编号
     * @param headNum : 表头行数，1表示1行
     * @param rowNum : 行号，索引从0开始，即0为第一行
     * @return java.util.List<java.lang.String>
     * @throws
     */
    public static List<String> getHeadListNoModel(String fileName,Integer sheetNo,Integer headNum,Integer rowNum){
        NoModelListener noModelListener = new NoModelListener();
        EasyExcel.read(fileName, noModelListener).sheet(sheetNo).headRowNumber(headNum).doRead();
        List<Map<Integer, String>> headList = noModelListener.getHeadList();
        List<String> oneHead = new ArrayList<>();
        for (int i = 0; i < headList.size(); i++) {
            if(i==rowNum){
                Map<Integer, String> map = headList.get(i);
                for (Map.Entry<Integer, String> entry : map.entrySet()) {
                    oneHead.add(entry.getValue());
                }

            }
        }
        return oneHead;
    }
}
  1. 写入工具类WriteExcelUtil

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;

import java.util.List;

/**
 * 写入工具类
 */
public class WriteExcelUtil {

    // 有实体单独写一个sheet
    public static void writeSheet(String fileName,List<Object> list,Class obj,Integer sheetNo,String sheetName){
        ExcelWriter excelWriter = EasyExcel.write(fileName).build();
        WriteSheet writeSheet = EasyExcel.writerSheet(sheetNo, sheetName).head(obj).build();
        excelWriter.write(list, writeSheet);
        //千万别忘记finish 会帮忙关闭流
        excelWriter.finish();
    }

    //获取流
    public static ExcelWriter getExcelWriter(String fileName){
        ExcelWriter excelWriter = EasyExcel.write(fileName).build();
        return excelWriter;
    }
    //关闭流
    public static void closeExcelWriter(ExcelWriter excelWriter){
        //千万别忘记finish 会帮忙关闭流
        excelWriter.finish();
    }

    /**
     * 有实体多个sheet一起写，要使用同一个流
     * @param excelWriter : 写入流
     * @param list : 数据
     * @param obj : 对应实体类
     * @param sheetNo : sheet编号，0开始
     * @param sheetName : sheetName
     * @return void
     * @throws
     */
    public static void writeMultipleSheet(ExcelWriter excelWriter,List<Object> list,Class obj,Integer sheetNo,String sheetName){
        WriteSheet writeSheet = EasyExcel.writerSheet(sheetNo, sheetName).head(obj).build();
        excelWriter.write(list, writeSheet);
    }

    //
    /**
     * 无实体多个sheet一起写，要使用同一个流
     * @param excelWriter : 写入流
     * @param list : 数据,List<List<Object>>格式,每一个List<Object>代表一行数据
     * @param headList : 表头，List<List<String>,每一个List<String>代表一列的表头
     * @param sheetNo : sheet编号
     * @param sheetName : sheetName
     * @return void
     * @throws
     */
    public static void writeMultipleNoModel(ExcelWriter excelWriter,List<List<Object>> list,List<List<String>> headList,Integer sheetNo,String sheetName){
        WriteSheet writeSheet = EasyExcel.writerSheet(sheetNo, sheetName).head(headList).build();
        excelWriter.write(list, writeSheet);
    }

}
执行案例
  1. 有实体的多sheet读取
//有实体
        String fileName = "F:\\testFile\\excel\\stu.xlsx";
        Map<String, List<Object>> excelMap = new HashMap<String, List<Object>>();
        //第一张sheet--Student
        Map<String, List<Object>> m1 = ReadExcelUtil.getMap(fileName, Student.class, 0, 1);
        //第二张sheet--Cat
        Map<String, List<Object>> m2 = ReadExcelUtil.getMap(fileName, Cat.class, 1, 1);
        excelMap.putAll(m1);
        excelMap.putAll(m2);
        System.out.println(excelMap);
        //{Student=[Student(name=AA, age=11), Student(name=BB, age=22), Student(name=AADD, age=33), Student(name=AACC, age=11), Student(name=AAEE, age=5)], Cat=[Cat(name=aa, age=1), Cat(name=bb, age=2), Cat(name=cc, age=3), Cat(name=dd, age=4), Cat(name=ee, age=1)]}
  1. 无实体的多sheet读取
String fileName = "F:\\testFile\\excel\\stu.xlsx";
        Map<String, List<Map<Integer, String>>> excelMap = new HashMap<>();
        Map<String, List<Map<Integer, String>>> stuMap = ReadExcelUtil.getMapNoModel(fileName, 0, 1);
        Map<String, List<Map<Integer, String>>> catMap = ReadExcelUtil.getMapNoModel(fileName, 1, 1);
        excelMap.putAll(stuMap);
        excelMap.putAll(catMap);
        System.out.println(excelMap);
        //{Student=[{0=AA, 1=11}, {0=BB, 1=22}, {0=AADD, 1=33}, {0=AACC, 1=11}, {0=AAEE, 1=5}], Cat=[{0=aa, 1=1}, {0=bb, 1=2}, {0=cc, 1=3}, {0=dd, 1=4}, {0=ee, 1=1}]}
  1. 有实体的多sheet写入
		List<Object> stuList = new ArrayList<>();
        Object s1 = new Student("小明",10);
        Object s2 = new Student("小红",20);
        stuList.add(s1);
        stuList.add(s2);
        List<Object> catList = new ArrayList<>();
        Object c1 = new Cat("小明",10);
        Object c2 = new Cat("小红",20);
        catList.add(c1);
        catList.add(c2);
        String file = "F:/testFile/excel/writeTest"+System.currentTimeMillis()+".xlsx";
        ExcelWriter excelWriter = WriteExcelUtil.getExcelWriter(file);
        WriteExcelUtil.writeMultipleSheet(excelWriter,stuList,Student.class,0,"Student");
        WriteExcelUtil.writeMultipleSheet(excelWriter,stuList,Cat.class,1,"Cat");
        WriteExcelUtil.closeExcelWriter(excelWriter);
  1. 无实体的单sheet写入
		//此处造数据较麻烦，借无实体读获取数据再写入另一个文件
        //读取
        String fileName = "F:\\testFile\\excel\\stu.xlsx";
        //数据
        List<List<Object>> stuList = ReadExcelUtil.getOnlyListNoModel(fileName, 0, 1);
        //表头
        List<String> headList = ReadExcelUtil.getHeadListNoModel(fileName,  0, 1,0);
        List<List<String>> writeHeadList = new ArrayList<>();
        for (int i = 0; i < headList.size(); i++) {
            List<String> oneHead = new ArrayList<>();
            oneHead.add(headList.get(i));
            writeHeadList.add(oneHead);
        }
        //写入
        String file = "F:/testFile/excel/writeTest"+System.currentTimeMillis()+".xlsx";
        ExcelWriter excelWriter = WriteExcelUtil.getExcelWriter(file);
        WriteExcelUtil.writeMultipleNoModel(excelWriter,stuList,writeHeadList,0,"Student");
        WriteExcelUtil.closeExcelWriter(excelWriter);
更多
枫雨血痕
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
读取大数据量的excel文件
04-26
本案例采用的poi读取大数据的excel文件 usermodel模式对excel操作前需要将文件全部转入内存，对较大文件来说内存开销很大。但是其使用简单。 eventusermodel模式采用事件模型，对文件边读取边处理，内存消耗较低，...
EasyExcel读文件详解和源码分析
Charge8的博客
06-27 5245
EasyExcel读文件详解和源码分析
使用EasyExcel实现多种类型多sheet页的Excel导入
qq_42553489的博客
08-11 6575
使用EasyExcel实现多种类型多sheet页的Excel导入
java：EasyExcel使用（一）读excel
最新发布
a232884c的博客
05-01 1984
EasyExcel相比于传统使用poi进行excel文件读写，编程使用操作上更加方便快捷，且对于内存溢出进行了优化处理。本文是EasyExcel读excel操作。
EasyExcel
m0_72744405的博客
04-14 1430
EasyExcel入门
easyExcel获取所有sheet的列表或者名字，读取所有sheet页信息
远方
04-16 1万+
File file = new File("D://template.xlsx"); ExcelReaderBuilder excelReaderBuilder = EasyExcel.read(file); ExcelReader excelReader = excelReaderBuilder.build(); List<ReadSheet> sheets = excelReader.excelExecutor().sheetList(); for (ReadSheet sheet.
Java 开发必备，EasyExcel 操作详解！
s_156的博客
05-11 5428
EasyExcel-读 依赖： <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.39</version> </dependency> <dependency> <g
通过EasyExcel+线程池实现百万级数据从Excel导入到数据库
03-26
在处理大量数据导入数据库的场景中，使用阿里巴巴开源的EasyExcel库结合线程池技术可以有效地实现从Excel文件导入到数据库的过程。先定义sheet的数量和固定大小的线程池数量，每个sheet页做为单独的任务交给线程池...
阿里EasyExcel导出案例
01-19
阿里EasyExcel是一款由阿里巴巴开发的轻量级Java库，专门用于处理Excel文件，尤其是数据的导入和导出。它的设计目标是低内存消耗、高效性能和简单易用。在这个"阿里EasyExcel导出案例"中，我们将深入探讨如何利用...
easyexcel案例
03-05
这个例子通常会涵盖读取Excel、写入Excel、自定义模型解析等常见操作，帮助你快速掌握EasyExcel的使用。 总结，EasyExcel作为Java处理Excel的优秀工具，凭借其流式处理、低内存消耗、无需预定义模型等特性，为...
EasyExcel JAVA解析Excel工具 v3.3.3.zip
03-21
例如，在读取Excel数据时，我们可以通过实现`AnalysisEventListener`接口来自定义数据处理逻辑，然后使用`EasyExcel.read()`方法启动读取过程。在写入数据时，定义好对应的实体类，使用`EasyExcel.write()`方法即可...
EasyExcel读取多sheet excel异常
xl十一的博客
07-24 2144
使用Spring Boot集成EasyExcel进行导入excel多sheet，执行异常。
EasyExcel 动态设置多sheet名称
Apollo
03-02 3146
EasyExcel 动态设置多sheet名称
easyexcel获取所有sheet页名称_JavaEE开发必备！EasyExcel操作详解
weixin_39522103的博客
11-29 7272
点击上方蓝字关注,更多惊喜等着你EasyExcel-读依赖： <dependency> <groupId>com.alibabagroupId> <artifactId>fastjsonartifactId> <version>1.2.39v...
easyexcel获取所有sheet页名称_3.3.3 接口自动化测试框架之多个sheet用例管理
weixin_39756336的博客
11-27 717
木 头 课 堂小 木 前 言还记得上一章节我们遗留的一个问题吗？打开Excel发现数据没有写入到实际结果，原因是什么？如果这个大家没理解那么就说明大家的基本功不够扎实呀。实际并不是保存也不是对象获取错误的问题，而是赋值的问题。如果我们创建对象调用将对象赋值给一个变量的话，那么再次实现赋值字符串，实际就是将cell对象转换成了str对象。还记得我们前面讲过的test="cell"test=...
easyExcel 多sheet导出
写代码的吴彦祖
12-28 2049
仅供参考。注意点1是多sheet导出时，sheetNo 和 sheetName 要根据页数变更。如果sheetName一样，会导出在一个sheet中，另外我是自定义head，不是用对象去定义的。这样更灵活些。 @Override public void exprot(HttpServletResponse response,List<Long> ids) { List<SupplyPlanHeadDTO> exportData = new ArrayList<&gt.
EasyExcel读取Excel数据(含多种方式)
热门推荐
m0_59084856的博客
12-15 1万+
简单地说，EasyExce是一个Java库，用于快速、简单地读写Excel文件以下是官网的简介：Java解析、生成Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。
Java(107):EasyExcel读取数据(不包括表头)到List＜Map＞
fen_fen的专栏
02-06 2894
EasyExcel读取数据(不包括表头)到List
easyExcel(第三方接口使用List＜Map＞返回数据)
爱喝茶的熊的博客
09-13 2555
easyExcel导出listMap
easyexcel 读取excel文件
03-30
EasyExcel是一款基于Java的开源工具，用于读取和写入Excel文件。它提供了简单易用的API，可以方便地进行Excel文件的读写操作。 使用EasyExcel读取Excel文件非常简单，只需按照以下步骤进行操作： 1. 引入EasyExcel的依赖包。 2. 创建一个Java类，作为数据模型，用于存储读取到的Excel数据。 3. 使用EasyExcel提供的API，打开Excel文件并读取数据。 4. 将读取到的数据存储到数据模型中。 5. 关闭Excel文件。 以下是使用EasyExcel读取Excel文件的示例代码： ```java // 引入EasyExcel的依赖包 import com.alibaba.excel.EasyExcel; // 创建数据模型类 public class ExcelData { private String name; private int age; // 其他属性... // getter和setter方法... } // 读取Excel文件 public class ReadExcel { public static void main(String[] args) { // Excel文件路径 String filePath = "path/to/excel/file.xlsx"; // 使用EasyExcel提供的API，打开Excel文件并读取数据 EasyExcel.read(filePath, ExcelData.class, new ExcelDataListener()).sheet().doRead(); } } // 自定义监听器类，用于处理读取到的数据 public class ExcelDataListener extends AnalysisEventListener<ExcelData> { // 重写父类的方法，处理每一行读取到的数据 @Override public void invoke(ExcelData data, AnalysisContext context) { // 将读取到的数据存储到数据模型中，可以进行自定义操作 System.out.println("Name: " + data.getName()); System.out.println("Age: " + data.getAge()); // 其他操作... } // 重写父类的方法，读取完成后的操作 @Override public void doAfterAllAnalysed(AnalysisContext context) { // 关闭Excel文件等资源 } } ``` 以上就是使用EasyExcel读取Excel文件的简单介绍和示例代码。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值