Excel工具类实现——基于poi5.2.3

已于 2023-01-18 11:00:00 修改
阅读量1.1k 收藏 2
点赞数 1
分类专栏： JAVA 文章标签： excel java 开发语言
于 2023-01-14 08:59:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45636641/article/details/128682009
版权

初衷仅是因为网上的Excel工具类不是太老旧的方法，就是不是很满足我想法，就想要自己搞一个，不过还不支持合并单元格等复杂的操作，后续看看能不能优化，有大神有更好的方法，可以公众号联系我，让我学习学习
原文及源码链接：Excel工具类实现

Excel工具类实现

整体设计

使用方式

// @Sheet 不是必须的, 如果需要设置字体颜色/背景色, 可以使用该注解
@Sheet(bgColor = "#CBCBCB")
public class Demo {

    @SheetColumn(name = "ID")
    public Integer id;

    @SheetColumn(name = "Name")
    public String name;

    @SheetColumn(name = "Description", width = 30) // 宽度接近英文字符数
    public String description;

    // 默认为: yyyy-MM-dd, 根据实际情况设置
    @SheetColumn(name = "Created At", dateFormat = "yyyy-MM-dd HH:mm:ss")
    public LocalDateTime createdAt;

}
//读群数据
ExcelReader<Demo> reader=Excel.createReader(Demo::new);
reader.setEvaluateFormula(true); // 如果需要计算公式, 请设置为 true
List<Demo> list=reader.read(inputStream);
//写入数据
ExcelWriter<Demo> writer=Excel.createWriter(Demo.class);
Demo demo=new Demo();
demo.name="哈哈";
demo.createdAt=LocalDateTime.now();
...
    writer.write(demo);// 也可以是 List
writer.save(new FileOutputStream("D:/a.xlsx"));

需要依赖

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>5.2.3</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>5.2.3</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-scratchpad</artifactId>
    <version>5.2.3</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
</dependency>

代码实现

  1. 首先Excel类只定义了读写创建器和部分跟读写关系不大的方法，具体的实现由读写类内部实现，使用起来比较清晰

    /**
 * @author ZeroClian
 * @date 2023-01-10 15:35
 */
public class Excel {
    private static final Logger logger = LoggerFactory.getLogger(Excel.class);

    public static <T> ExcelReader<T> createReader(Supplier<T> supplier) {
        return new ExcelReader<>(supplier);
    }

    public static <T> ExcelWriter<T> createWriter(Class<T> clazz) {
        return new ExcelWriter<>(clazz);
    }


    public static Object getCellValue(Cell cell, FormulaEvaluator formulaEvaluator) {
        switch (cell.getCellType()) {
            case ERROR:
                return ErrorEval.getText(cell.getErrorCellValue());
            case BLANK:
                return "";
            case BOOLEAN:
                return cell.getBooleanCellValue();
            case FORMULA:
                if (formulaEvaluator == null) {
                    return cell.getCellFormula();
                } else {
                    CellValue cellValue = formulaEvaluator.evaluate(cell);
                    if (cellValue.getCellType() == CellType.NUMERIC) {
                        return cellValue.getNumberValue();
                    }
                    if (cellValue.getCellType() == CellType.STRING) {
                        return cellValue.getStringValue();
                    }
                    if (cellValue.getCellType() == CellType.BOOLEAN) {
                        return cellValue.getBooleanValue();
                    }
                    return cellValue.toString();
                }
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    return cell.getDateCellValue();
                }
                return cell.getNumericCellValue();
            case STRING:
                return cell.getRichStringCellValue().toString();
            default:
                logger.error("Unknown Cell Type: {}", cell.getCellType());
                return null;
        }
    }

    /**
     * 26进制转换为十进制, 然后减去一(列索引基于0)
     *
     * @param name
     * @return
     */
    public static int toColumnIndex(String name) {
        int n = 0;
        for (int i = name.length() - 1, j = 1; i >= 0; i--, j *= 26) {
            char c = name.charAt(i);
            if (c < 'A' || c > 'Z') return 0;
            n += ((int) c - 64) * j;
        }
        return n - 1;//index要减一
    }

    /**
     * @param nm 例如: #FFCCEE
     * @return
     */
    static XSSFColor createColor(String nm) {
        java.awt.Color color = java.awt.Color.decode(nm);
        byte r = (byte) color.getRed();
        byte g = (byte) color.getGreen();
        byte b = (byte) color.getBlue();
        return new XSSFColor(new byte[]{r, g, b});
    }

}

  2. 读excel核心就是如何将获取的值与Field字段对应，这里采用的自定义注解的方式，通过excel文件的列名与注解的列名对应即可，之后就是将cell值转换为对应的对象，再为field赋值，注意如果是private修饰的，需要添加field.setAccessible(true)

    /**
 * @author ZeroClian
 * @date 2023-01-10 15:35
 */
public class ExcelReader<T> {

    private static final Logger logger = LoggerFactory.getLogger(Excel.class);
    private static final DefaultConversionService convert = new DefaultConversionService();

    private final Supplier<T> supplier;
    private boolean evaluateFormula = false;
    private FormulaEvaluator formulaEvaluator = null;

    public ExcelReader(Supplier<T> supplier) {
        this.supplier = supplier;
    }

    /**
     * 设置自动计算公式
     *
     * @param evaluateFormula true表示执行计算
     */
    public void setEvaluateFormula(boolean evaluateFormula) {
        this.evaluateFormula = evaluateFormula;
    }

    /**
     * 读取Excel
     *
     * @param in 输入流
     * @return {@link List<T> objects} 对象列表
     * @throws IOException
     */
    public List<T> read(InputStream in) throws IOException {
        Workbook workbook = WorkbookFactory.create(in);
        if (evaluateFormula) {
            this.formulaEvaluator = workbook.getCreationHelper().createFormulaEvaluator();
        }
        //读取数据
        List<T> list = new ArrayList<>();
        for (Sheet sheet : workbook) {
            List<String> headers = getSheetHeaders(sheet);
            Iterator<Row> rowIterator = sheet.rowIterator();
            while (rowIterator.hasNext()) {
                Row row = rowIterator.next();
                if (row.getRowNum() == 0) {
                    continue;
                }
                T obj = rowToObject(headers, row, supplier);
                if (null != obj) {
                    list.add(obj);
                }
            }
        }
        return list;
    }

    /**
     * 获取列名（位于第一行）
     *
     * @param sheet 页
     * @return {@link List<String> headers} 列名列表
     */
    public List<String> getSheetHeaders(Sheet sheet) {
        Row row = sheet.getRow(0);
        List<String> headers = new ArrayList<>();
        for (Cell cell : row) {
            String cellValue = cell.getStringCellValue();
            headers.add(cellValue);
        }
        return headers;
    }

    /**
     * 单行转为对象
     *
     * @param headers  列名
     * @param row      行
     * @param supplier 要转换的对象
     * @return {@link Object}
     */
    private T rowToObject(List<String> headers, Row row, Supplier<T> supplier) {
        try {
            T obj = supplier.get();
            //获取字段
            Field[] fields = obj.getClass().getDeclaredFields();
            boolean isEmpty = true;
            for (Field field : fields) {
                SheetColumn ec = field.getAnnotation(SheetColumn.class);
                if (null == ec) continue;
                int columnIndex = headers.indexOf(ec.name());
                if (columnIndex >= 0) {
                    Cell cell = row.getCell(columnIndex);
                    if (null != cell) {
                        isEmpty = setValue(obj, field, cell, ec.dateFormat());
                    }
                }
            }
            return isEmpty ? null : obj;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 向对象设置值
     *
     * @param obj        对象
     * @param field      字段
     * @param cell       单元格
     * @param dateFormat 日期格式
     */
    private boolean setValue(T obj, Field field, Cell cell, String dateFormat) throws IllegalAccessException, ParseException {
        Object value = Excel.getCellValue(cell, formulaEvaluator);
        if (null == value) return true;
        boolean emptyValue = ObjectUtils.isEmpty(value);
        Class<?> valueClass = value.getClass();
        Class<?> fieldClass = field.getType();
        field.setAccessible(true);
        if (fieldClass == valueClass) {
            field.set(obj, value);
            return false;
        }
        //java8 日期、时间
        if (Temporal.class.isAssignableFrom(fieldClass)) {
            if (emptyValue) {
                return true;
            }
            String cellStr = value.toString();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(dateFormat);
            if (LocalDateTime.class.isAssignableFrom(fieldClass)) {
                field.set(obj, LocalDateTime.parse(cellStr, formatter));
            }
            if (LocalDate.class.isAssignableFrom(fieldClass)) {
                field.set(obj, LocalDate.parse(cellStr, formatter));
            }
            if (OffsetDateTime.class.isAssignableFrom(fieldClass)) {
                field.set(obj, OffsetDateTime.parse(cellStr, formatter));
            }
        }
        //java.util.Date
        if (Date.class.isAssignableFrom(fieldClass)) {
            if (emptyValue) {
                return true;
            }
            String cellStr = value.toString();
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            Date date = format.parse(cellStr);
            field.set(obj, date);
            return false;
        }
        if (convert.canConvert(valueClass, fieldClass)) {
            Object newValue = ExcelReader.convert.convert(value, fieldClass);
            if (null != newValue) {
                field.set(obj, newValue);
            }
            return false;
        }
        throw new IllegalArgumentException("表数据类型与类字段类型不一致: " + value.getClass() + " -> " + field.getType());
    }
}

  3. 导出则比较简单，只是将对象转换为对应列的值，跟其他人的区别是，增加了表头的注解，用于简单设置导出的颜色背景样式，

    /**
 * @author ZeroClian
 */
public class ExcelWriter<T> implements AutoCloseable {

    private static final Logger logger = LoggerFactory.getLogger(Excel.class);

    private final Class<T> clazz;
    private final SXSSFWorkbook workbook;
    private SXSSFSheet sheet;
    private Map<Field, Header> fieldHeaderMap;

    public ExcelWriter(Class<T> clazz) {
        this.clazz = clazz;
        this.workbook = new SXSSFWorkbook(300);
        this.init();
        this.createSheet();
    }

    /**
     * 获取字段对应的列
     */
    public void init() {
        Map<Field, Header> map = new LinkedHashMap<>();
        Set<Integer> usedIndex = new HashSet<>();
        Queue<Integer> queue = new LinkedList<>();
        for (Field field : clazz.getDeclaredFields()) {
            SheetColumn ec = field.getAnnotation(SheetColumn.class);
            if (null == ec) continue;
            int columnIndex = -1;
            if (!ec.column().isEmpty()) {
                columnIndex = Excel.toColumnIndex(ec.column());
                if (!usedIndex.add(columnIndex)) {
                    logger.warn("重复列编号: {}", ec.column());
                }
            }
            Header header = new Header(ec.name(), ec.column(), columnIndex, ec.dateFormat(), ec.width());
            map.put(field, header);
            queue.add(queue.size());
        }
        queue.removeAll(usedIndex);
        map.forEach((field, header) -> {
            if (header.getColumnIndex() < 0) {
                header.setColumnIndex(queue.remove());
            }
        });
        this.fieldHeaderMap = map;
    }

    /**
     * 创建Sheet和表头
     */
    public void createSheet() {
        String name = "Sheet1";
        String color = "#000000";
        String bgColor = "#CBCBCB";
        Sheet sheetInfo = clazz.getAnnotation(Sheet.class);
        if (null != sheetInfo) {
            if (!sheetInfo.name().isBlank()) {
                name = sheetInfo.name();
            }
            color = sheetInfo.color();
            bgColor = sheetInfo.bgColor();
        }
        this.sheet = workbook.createSheet(name);
        //表头
        Row headerRow = sheet.createRow(0);
        CellStyle cellStyle = workbook.createCellStyle();
        cellStyle.setFillForegroundColor(Excel.createColor(bgColor));
        cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        cellStyle.setAlignment(HorizontalAlignment.CENTER);
        XSSFFont font = (XSSFFont) workbook.createFont();
        font.setColor(Excel.createColor(color));
        font.setBold(true);
        cellStyle.setFont(font);
        sheet.trackAllColumnsForAutoSizing();
        fieldHeaderMap.forEach((field, header) -> {
            if (header.getColumnWidth() > 0) {
                int width = Math.min(16_384, header.getColumnWidth() * 256);
                sheet.setColumnWidth(header.getColumnIndex(), width);
            } else if (header.getColumnWidth() == 0) {
                sheet.setColumnHidden(header.getColumnIndex(), true);
            } else {
                sheet.autoSizeColumn(header.getColumnIndex());
            }
        });
        fieldHeaderMap.forEach((field, header) -> {
            Cell cell = headerRow.createCell(header.getColumnIndex());
            cell.setCellStyle(cellStyle);
            cell.setCellValue(header.getName());
        });
    }

    /**
     * 写入单个对象
     *
     * @param obj 对象
     * @throws IOException
     */
    public void write(T obj) throws IOException {
        try {
            if (null == obj) {
                return;
            }
            Row row = sheet.createRow(sheet.getLastRowNum() + 1);
            for (Map.Entry<Field, Header> entry : fieldHeaderMap.entrySet()) {
                Cell cell = row.createCell(entry.getValue().getColumnIndex());
                Field field = entry.getKey();
                Header header = fieldHeaderMap.get(field);
                Object cellValue = field.get(obj);
                String value;
                if (cellValue instanceof Date date) {
                    value = DateFormatUtils.format(date, header.getDateFormat());
                } else if (cellValue instanceof Temporal temporal) {
                    value = DateTimeFormatter.ofPattern(header.getDateFormat()).format(temporal);
                } else {
                    value = Objects.toString(cellValue, "");
                }
                cell.setCellValue(value);
            }
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public void write(List<T> list) throws IOException {
        for (T obj : list) {
            write(obj);
        }
    }

    public void save(OutputStream out) throws Exception {
        workbook.write(out);
        close();
    }

    @Override
    public void close() throws Exception {
        this.workbook.close();
    }

}

  4. 剩余就是注解的定义，这里我只定义了常用的，可自行修改

    /**
 * Excel表整体格式配置（非必选）
 * 主要用于设置表格格式
 * 修改：字体颜色，背景颜色
 *
 * @author ZeroClian
 * @date 2023-01-06 20:08
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Sheet {

    /**
     * 表名
     */
    String name() default "";

    /**
     * 字体颜色
     */
    String color() default "#000000";

    /**
     * 背景颜色
     */
    String bgColor() default "#CBCBCB";
}

/**
 * 列注解
 *
 * @author ZeroClian
 * @date 2023-01-06 20:20
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SheetColumn {

    String name() default "";

    String column() default "";

    int width() default 16;

    String dateFormat() default "yyyy-MM-dd";
}

/**
 * @author Justin
 */
@Data
public class Header {

    private String name;
    private String column;
    private int columnIndex;
    private String dateFormat;
    private int columnWidth;
    private XSSFColor color;
    private XSSFColor bgColor;

    public Header(String name, String column, int columnIndex, String dateFormat, int columnWidth) {
        this.name = name;
        this.column = column;
        this.columnIndex = columnIndex;
        this.dateFormat = dateFormat;
        this.columnWidth = columnWidth;
    }
}
ZeroClian
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
poi处理Excel数据
芝麻年糕的博客
10-12 418
最近做项目，有一个上传excel文件，将文件中的数据存储到数据库中，遇到几个问题。 1.批量插入数据报错 如果列表为空，MYSQL执行批量插入时会报错，在进行批量插入之前，需要进行判断，如果需要保存的数据列表为空或者是list.size()=0,则不要进行插入操作 2.批量插入数据，对于重复数据，如果不想重复保存的情况（唯一性约束） 唯一性约束：如果不是主键的话，可以选择唯一性约束，可以选择一个护着多个变量来确定数据的唯一性 <!--唯一性约束--> alter table 表名 add CON
Apache POI升级5.2.3后报错NestedServletException: org.apache.commons.io.IOUtils.byteArray(I)[B
王小义笔记
03-25 645
升级脚手架(springboot版本及一系列的pom依赖)之后提示报错NoSuchMethodError，
poi低版本工具类换成poi5.2导出excel表头
最新发布
tellmewhoisi的博客
05-11 995
之前写的低版本poi 3.8工具是可以用，但是在导出的时候出现问题 所以还是得用高版本工具，原来低版本链接poi低版本导入excel表头 问题 在处理Excel文件时，您可能已经使用了Apache POI库。然而，在使用过程中，您可能会遇到一个常见的错误：java.lang.NoSuchFieldError:Factory。这个错误通常意味着在运行时环境中存在类路径问题或不同版本的POI库冲突 解决办法 我把之前低版本poi 3.8 兼容删除，把里面工具类都换成5.2 最新的工具类 ExcelColorHe
POI操作Excel
半坡人的博客
06-02 1209
文章目录1.POI简单概述2.创建一个普通maven项目3.导入org.apache.poi的jar包4.导入excel方法5.导出excel方法6.总结 1.POI简单概述 JAVA中操作Excel的有两种比较主流的工具包： JXL 和 POI 。jxl 只能操作Excel 95, 97, 2000也即以.xls为后缀的excel。而poi可以操作Excel 95及以后的版本，即可操作后缀为 ....
Java使用poi 5.0解析Excel工作簿的例子
我一时想不起的博客
08-22 4252
Excel文档是日常办公中非常普遍的一种数据记录模式。在业务场景中，往往有“导入Excel到某某系统中”的需求，所以这里记录一种使用poi 5.0系列的jar包解析为Java实体类的方法。 结合POI5.0的org.apache.poi.ss.usermodel.WorkBook接口，先将Excel工作簿抽象为工作表、标题、数据行。通过HSSFWorkbook和XSSFWorkbook实现类的方法，将Sheet顺序号和指定的行号作为可配置的参数，获取有关对象后转换为实体类。
poi5.0设置excel样式
weixin_42440765的博客
09-22 693
//创建Excl文件 HSSFWorkbook wb = new HSSFWorkbook(); //创建工作表 HSSFSheet sheet = wb.createSheet("sheet1"); //新建居中样式 CellStyle style = wb.createCellStyle(); style.setAlignment(HorizontalAlignment.CENTER); //获取第1行 HSSFRow row0 = sheet.createRow(0); //获取第一行的第一个单元格
最新Apache POI 5.2.3jar包和源码
02-12
2. **poi-5.2.3.jar**: 这是Apache POI的核心库，包含了处理HSSF（Excel的低级API，用于老版本的.xls文件）和XSSF（Excel的高级API，用于.xlsx文件）所需的所有类和方法。 3. **poi-ooxml-5.2.3.jar**: 这个库用于...
基于poi的excel导入导出工具类
04-03
基于poi的excel导入导出封装，poi版本 <groupId>org.apache.poi <artifactId>poi <version>4.1.0 <groupId>org.apache.poi <artifactId>poi-ooxml <version>4.1.0 </dependency>
java使用POI导出 Excel工具类
08-14
java使用POI导出 Excel+图片工具类 ，里面含有poi jar包，只调用接口即可直接保存Excel。使用的时候需先把数据封装，具体包装需根据实际导出数据进行处理。文件demo中只提供包装格式。
基于POI的Excel多Sheet页导出导入工具类
02-13
"基于POI的Excel多Sheet页导出导入工具类"是一个实用的Java类库，专为处理Excel文件中的多个工作表（Sheet）而设计，提供了一种高效且灵活的方式来操作Excel数据。 该工具类的核心功能包括： 1. **多Sheet页操作**...
java 基于poi的excel操作工具类
03-20
本文将深入探讨基于Apache POI的Java Excel操作工具类的实现，包括导入Excel、导出Excel以及直接存储到服务器或返回流。 首先，`ExcelUtil.java` 文件很可能是这个工具类的核心实现，它包含了对Excel文件的各种操作...
poi-5.2.2 版本整体工具类
07-21
没太多时间整理，有朋友需要就先贴出来了，缺失留言 包含word、段落、页眉、页脚、图片、表格等常用工具方法
Apache的POI开发实例
02-22
Apache的POI组件是Java操作Microsoft Office办公套件的强大API，其中对Word，Excel和PowperPoint都有支持，当然使用较多的还是Excel，因为Word和PowerPoint用程序动态操作的应用较少。那么本文就结合POI来介绍一下操作Excel的方法。 Office 2007的文件结构完全不同于2003，所以对于两个版本的Office组件，POI有不同的处理API，分开使用即可。首先来说几个Excel的基本概念。对于一个Excel文件，这称为一个工作簿（Workbook），打开Excel之后，在下方会有sheet1/2/3这样的选项卡，点击可以切换到不同的sheet中，这个sheet称作工作表。每个工作表就是我们编辑的区域，这是一张二维表，阿拉伯数字控制行数，从1开始，而程序中还是0，类似数组和集合。字母控制列数，从A开始，Z以后是两个字母控制。对于每一行，我们称为Row，列就是Column，行列可以确定唯一的一个元素，那么就是单元格，称为Cell。 POI组件可以方便的操纵这些元素，但初次接触POI可能会有畏惧心理，因为要对每个单元格进行设置，那么不管是用数组还是集合，从工作簿，工作表，行下来的代码量都不会小，这是不能避免的，但是按照这个处理顺序走，就一定可以得到结果。
POI处理Excel全流程
sunny-Jin在路上
08-26 1231
最近项目需要使用POI对Excel数据进行处理，之前也用过，但是记忆不是很深刻，今天重新做的时候发现基本已经忘完，所以重新再做一次，以此记录。 首先，到官网下去下载poi的jar包，解压jar包，可以看见文件夹中有相关的jar包。但是官网上下载的jar包少了一个jar包，需要重新到Reposity 上去下载，它就是commons-compress-1.18.jar，这个jar包至关重要！！！因为...
Java使用POI读取Excel名称管理器
namelessmyth的专栏
08-04 888
使用poi读取到Excel的名称管理器中的内容
java使用POI5.0生成简易Excel工作簿的一种方法
我一时想不起的博客
05-06 3014
先贴一下poi相关jar包的链接 https://poi.apache.org/download.html#POI-5.0.0 官网地址 <!-- https://mvnrepository.com/artifact/org.apache.poi/poi --> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId>
POI Excel读取以及导入导出
weixin_45025511的博客
10-12 546
poi对excel的读取操作以及导入导出
poi读取EXCEL工具，兼容2003以下和2007
mcj010的专栏
02-16 790
最近在开发一个excel数据导入时，发现poi导入2003和2007版本是不兼容的，原来在2007的excel文本根式是xml，不是以前的2进制   必须另外处理，所以利用了一个简单工厂方法去根据文件类型去作不同处理   package com.wichina.common.util; import java.io.BufferedInputStream; import java.io
POI+EasyExcel，简单使用
m0_65041486的博客
10-16 815
​ApachePOI 是用Java编写的免费开源的跨平台的 Java API，Apache POI提供API给Java程序对格式档案读和写的功能。
poi 5.2.3 接入
07-31
POI（Poor Obfuscation Implementation）是一种用于操作Microsoft Office格式文件（如Excel、Word）的Java API库。接入POI 5.2.3版本是指在Java项目中使用POI库的5.2.3版本。 要将POI 5.2.3接入到项目中，首先需要在项目中引入POI库的相关依赖。可以通过在项目的构建配置文件中添加POI的依赖坐标或者手动下载POI库的JAR文件并导入到项目中。接入POI库之后，就可以在代码中使用POI提供的功能来操作Microsoft Office格式文件了。 例如，如果想要通过POI库来读取Excel文件，可以使用POI提供的类和方法来完成。首先，需要创建一个Workbook对象，然后通过该对象打开Excel文件。接下来，可以根据需要选择要操作的Sheet和Row，通过getCell()方法获取单元格对象，并使用getStringCellValue()方法获取单元格的值。通过这样的方式，就可以实现对Excel文件的读取操作。 除了读取Excel文件，POI库还提供了许多其他功能，如写入Excel文件、操作Word文件等。通过POI的丰富功能，可以在Java项目中方便地实现对Microsoft Office格式文件的操作需求。 总结来说，接入POI 5.2.3版本是指在Java项目中使用POI库的5.2.3版本。通过引入POI的相关依赖，开发人员可以在代码中使用POI提供的功能来操作Microsoft Office格式文件，如读写Excel、操作Word等。这样，就可以满足项目中对这些文件格式的操作需求。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值