Java高效读取Excel数据技巧

还在为Java读取Excel数据而烦恼吗？本文将为你提供一套实用的解决方案。通过引入强大的Apache POI库，你将能够轻松处理各种Excel文件，无论是老式的.xls还是新式的.xlsx。文章详细介绍了如何使用Maven添加POI依赖，以及如何加载Excel文件、遍历工作表和单元格来获取数据。针对不同类型的单元格，如字符串、数字、日期和公式，文章也提供了相应的处理方法。此外，还探讨了如何处理文件异常，以及如何使用SAX解析器实现流式读取，避免大型Excel文件导致的内存溢出。最后，文章还介绍了如何将读取的数据映射到POJO对象，并通过JDBC、MyBatis等工具批量插入数据库，实现数据的持久化。掌握这些技巧，你将能够高效地在Java中读取和处理Excel数据。

在Java中导入和读取Excel文件最常用的是Apache POI库，1. 首先通过Maven添加poi和poi-ooxml依赖；2. 使用WorkbookFactory.create()加载Excel文件并自动识别格式；3. 遍历Sheet、Row和Cell获取数据；4. 根据CellType判断单元格类型并处理字符串、数字、日期、公式等不同类型；5. 通过try-catch捕获IOException和InvalidFormatException处理文件异常；6. 对于大型Excel文件使用SAX解析器实现流式读取避免内存溢出；7. 将读取的数据映射到POJO对象后，可通过JDBC、MyBatis等工具批量插入数据库完成持久化。

在Java中导入和读取Excel文件，最常用且功能强大的库无疑是Apache POI。它提供了一整套API，能够处理Microsoft Office格式的文件，无论是老式的.xls还是新式的.xlsx，都能游刃有余地应对。简单来说，就是通过这个工具包，我们能像操作普通数据结构一样，读取Excel里的每一个单元格内容。

解决方案

要使用Java读取Excel数据，核心步骤可以概括为：引入Apache POI库，加载Excel文件，然后遍历工作表、行和单元格来获取数据。

首先，你需要在你的项目构建工具中添加Apache POI的依赖。如果你用Maven，大概是这样：

<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> <!-- 处理.xlsx文件需要此依赖 -->
</dependency>

接下来，就是编写读取逻辑了。一个基本的读取流程是这样的：

import org.apache.poi.ss.usermodel.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;

public class ExcelReaderExample {

    public static void readExcel(String filePath) {
        try (InputStream excelFile = new FileInputStream(filePath)) {
            // 根据文件类型创建不同的工作簿对象
            // WorkbookFactory.create(InputStream) 可以自动识别.xls和.xlsx
            Workbook workbook = WorkbookFactory.create(excelFile);

            // 获取第一个工作表，或者通过名称获取
            Sheet sheet = workbook.getSheetAt(0); // 获取第一个sheet
            // Sheet sheet = workbook.getSheet("Sheet1"); // 通过名称获取

            // 遍历所有行
            Iterator<Row> rowIterator = sheet.iterator();
            while (rowIterator.hasNext()) {
                Row currentRow = rowIterator.next();

                // 跳过标题行，如果你有的话
                // if (currentRow.getRowNum() == 0) {
                //     continue;
                // }

                // 遍历当前行的所有单元格
                Iterator<Cell> cellIterator = currentRow.iterator();
                while (cellIterator.hasNext()) {
                    Cell currentCell = cellIterator.next();

                    // 根据单元格类型获取值
                    switch (currentCell.getCellType()) {
                        case STRING:
                            System.out.print(currentCell.getStringCellValue() + "\t");
                            break;
                        case NUMERIC:
                            // 处理日期和数字
                            if (DateUtil.isCellDateFormatted(currentCell)) {
                                System.out.print(currentCell.getDateCellValue() + "\t");
                            } else {
                                System.out.print(currentCell.getNumericCellValue() + "\t");
                            }
                            break;
                        case BOOLEAN:
                            System.out.print(currentCell.getBooleanCellValue() + "\t");
                            break;
                        case FORMULA:
                            // 对于公式，可以尝试获取其计算结果
                            System.out.print(currentCell.getCellFormula() + " -> " + currentCell.getNumericCellValue() + "\t");
                            break;
                        case BLANK:
                            System.out.print("[空白]\t");
                            break;
                        default:
                            System.out.print("[未知类型]\t");
                    }
                }
                System.out.println(); // 换行
            }
        } catch (IOException e) {
            System.err.println("文件读取错误: " + e.getMessage());
        } catch (org.apache.poi.openxml4j.exceptions.InvalidFormatException e) {
            System.err.println("Excel文件格式错误: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        String filePath = "path/to/your/excel_file.xlsx"; // 替换为你的Excel文件路径
        readExcel(filePath);
    }
}

这段代码涵盖了读取Excel文件的基本流程，包括如何打开文件、遍历工作表、行和单元格，并根据单元格类型获取其内容。WorkbookFactory.create()是个非常方便的方法，它能自动判断你的Excel文件是.xls还是.xlsx格式，并创建相应的HSSFWorkbook或XSSFWorkbook实例。

Java读取Excel文件时如何处理不同数据类型和潜在错误？

说实话，刚开始接触Excel处理，最让人头疼的就是数据类型转换和那些莫名其妙的空指针异常。Excel单元格的数据类型远比我们想象的要复杂，它不只是简单的字符串或数字。POI提供了CellType枚举来表示这些类型：STRING、NUMERIC（包含数字和日期）、BOOLEAN、FORMULA、BLANK、ERROR。

处理不同数据类型，关键在于使用currentCell.getCellType()判断当前单元格的实际类型，然后调用对应的方法（如getStringCellValue()、getNumericCellValue()等）来获取值。特别要注意的是数字类型，Excel中日期也是以数字形式存储的，所以你需要用DateUtil.isCellDateFormatted(cell)来判断是否为日期，然后用getDateCellValue()获取。否则，你可能会得到一串看起来毫无意义的浮点数。

至于潜在错误，文件不存在、路径错误、文件被占用、Excel文件本身损坏或格式不正确都是常见的坑。使用try-catch块来捕获IOException（文件读写问题）和InvalidFormatException（Excel文件格式问题）是必不可少的。另外，在遍历单元格时，如果某个单元格是空的（BLANK类型），直接调用getStringCellValue()等方法可能会抛出NullPointerException，所以最好在获取值之前进行null检查或者确保你的逻辑能够处理BLANK类型。

我的经验是，在实际项目中，我会封装一个工具类，针对不同列的数据类型做更精细的判断和转换，比如有些看起来是数字的列，实际上我们希望它被当作字符串来处理（比如商品编码），这时候就不能简单地用getNumericCellValue()了，可能需要先尝试getStringCellValue()，如果不行再尝试其他方式。这种灵活性是处理真实世界Excel数据时必须考虑的。

大型Excel文件在Java中如何高效读取，避免内存溢出？

处理大型Excel文件，特别是.xlsx格式的，是个常见的挑战。默认的XSSFWorkbook实现会将整个Excel文件加载到内存中。如果你的文件有几十万甚至上百万行数据，这很容易导致OutOfMemoryError。这就像你试图把一个巨型图书馆的所有书都搬到你家客厅一样，显然不现实。

为了解决这个问题，Apache POI提供了SXSSFWorkbook（Streaming Usermodel API for XSSF）。SXSSFWorkbook是XSSFWorkbook的一个流式版本，它通过在磁盘上创建临时文件来存储行数据，而不是全部加载到内存中。当你创建了指定数量的行后，旧的行就会被写入磁盘，从而释放内存。

使用SXSSFWorkbook进行读取（虽然它主要用于写入，但其背后的流式思想在读取时也需要借鉴）： 对于读取，我们不能直接用SXSSFWorkbook来读。而是要使用XSSF and SAX (Streaming API for XML)。POI提供了SAX解析器，它不会一次性加载整个工作簿，而是逐个事件地解析XML结构（因为.xlsx文件本质上是XML文件）。

你需要自己实现一个XSSFSheetXMLHandler.SheetContentsHandler接口，来处理解析过程中遇到的各种事件，比如行开始、行结束、单元格值等。这个方法相对复杂，但对于超大型文件来说，是避免内存溢出的最佳实践。

// 这是一个简化的概念性示例，实际使用需要更复杂的逻辑
// 引入相关类：
// import org.apache.poi.xssf.eventusermodel.XSSFReader;
// import org.apache.poi.xssf.eventusermodel.XSSFSheetXMLHandler;
// import org.apache.poi.xssf.usermodel.XSSFComment;
// import org.xml.sax.InputSource;
// import org.xml.sax.XMLReader;
// import javax.xml.parsers.SAXParserFactory;

public class LargeExcelReader {
    public void readLargeExcel(String filePath) throws Exception {
        // ... SAX解析器设置和事件处理逻辑 ...
        // 核心思想是：不把所有数据都读到内存里，而是读一行处理一行
        // 伪代码：
        // XSSFReader xssfReader = new XSSFReader(OPCPackage.open(filePath));
        // XSSFSheetXMLHandler handler = new XSSFSheetXMLHandler(
        //     xssfReader.getStylesTable(), null, new MySheetContentsHandler(), false);
        // XMLReader parser = SAXParserFactory.newInstance().newSAXParser().getXMLReader();
        // parser.setContentHandler(handler);
        // parser.parse(new InputSource(xssfReader.getSheetsData().next()));
    }

    // MySheetContentsHandler 需要实现 XSSFSheetXMLHandler.SheetContentsHandler 接口
    // 在startRow()和endRow()中处理行数据，在cell()中处理单元格数据
}

简而言之，对于大文件，不要指望一次性把所有数据都塞进内存。采用流式处理（SAX解析）或者分批处理的策略，读一行处理一行，或者读一小段处理一小段，才是王道。这虽然增加了代码的复杂性，但能确保程序的稳定性和扩展性。

如何将Java读取的Excel数据映射到业务对象或持久化到数据库？

读取Excel数据往往不是目的，而是手段。最终我们通常需要将这些数据转换成程序中可操作的Java对象，或者直接存储到数据库中。

映射到业务对象（POJO）： 这是最常见的做法。假设你的Excel文件有“姓名”、“年龄”、“邮箱”三列，你可以创建一个对应的Java类：

public class User {
    private String name;
    private int age;
    private String email;

    // 构造函数、getter、setter...
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    // 省略getter/setter
}

然后在读取Excel的循环中，为每一行创建一个User对象，并将单元格数据设置到对象的属性中。

List<User> userList = new ArrayList<>();
// ... 在Excel读取循环中 ...
Row currentRow = rowIterator.next();
// 假设第一列是姓名，第二列是年龄，第三列是邮箱
String name = currentRow.getCell(0).getStringCellValue();
int age = (int) currentRow.getCell(1).getNumericCellValue();
String email = currentRow.getCell(2).getStringCellValue();

userList.add(new User(name, age, email));
// ...

这种方式清晰直观，将原始的表格数据结构化为程序可理解的对象，方便后续的业务逻辑处理。

持久化到数据库： 将Excel数据导入数据库，通常是在将数据映射到POJO之后进行。你可以遍历userList，然后使用JDBC、MyBatis、Hibernate等工具将每个User对象的数据插入到数据库表中。

为了提高效率，特别是数据量大的时候，强烈建议使用JDBC的批量插入（Batch Insert）。而不是每读取一行就执行一次INSERT语句。批量插入可以显著减少数据库连接和网络往返的开销。

// 伪代码，使用JDBC批量插入
// Connection conn = null;
// PreparedStatement pstmt = null;
// try {
//     conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
//     conn.setAutoCommit(false); // 关闭自动提交，进行手动提交
//     String sql = "INSERT INTO users (name, age, email) VALUES (?, ?, ?)";
//     pstmt = conn.prepareStatement(sql);
//
//     for (User user : userList) { // 假设userList已经从Excel中读取并填充
//         pstmt.setString(1, user.getName());
//         pstmt.setInt(2, user.getAge());
//         pstmt.setString(3, user.getEmail());
//         pstmt.addBatch(); // 添加到批处理
//     }
//
//     pstmt.executeBatch(); // 执行批处理
//     conn.commit(); // 提交事务
// } catch (SQLException e) {
//     conn.rollback(); // 出现异常回滚
//     e.printStackTrace();
// } finally {
//     // 关闭资源
// }

整个流程下来，从文件读取到数据入库，形成了一个完整的闭环。实际操作中，错误处理、数据校验、以及更复杂的业务逻辑（比如数据去重、转换规则）都是需要重点考虑的环节。但核心思路，就是一步步将原始数据“洗干净”，然后放到它该去的地方。

今天关于《Java高效读取Excel数据技巧》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于java,Excel,ApachePOI,SAX解析,数据库持久化的内容请关注golang学习网公众号！