Mit der Entwicklung der Informatisierung wird die Bedeutung der Datenverarbeitung immer deutlicher. Für Unternehmen und Privatpersonen sind Excel-Arbeitsblätter zur am häufigsten verwendeten Datenverarbeitungsmethode in der täglichen Arbeit geworden. Obwohl Excel-Arbeitsblätter einfach zu verwenden sind, ist es mit der zunehmenden Datenmenge und den Verarbeitungsanforderungen jedoch oft schwierig, die Anforderungen praktischer Anwendungen mit herkömmlichen Excel-Verarbeitungsmethoden zu erfüllen. Derzeit ist die Verwendung der Apache POI-Bibliothek für die Excel-Verarbeitung in der Java-API-Entwicklung eine ausgezeichnete Wahl.
1. Einführung in Apache POI
Apache POI (Poor Obfuscation Implementation) ist eine kostenlose Java-Bibliothek zur Verarbeitung und Bedienung von Dateien im Microsoft Office-Format, einschließlich Word-, Excel- und PowerPoint-Dateien. Apache POI ermöglicht Java-Programmierern das einfache Lesen, Schreiben und Bearbeiten von Office-Dateien.
Apache POI kann grob in drei Teile unterteilt werden:
Dieser Artikel konzentriert sich hauptsächlich auf die Verwendung von HSSF und XSSF.
2. POI-Installation
Bevor wir Apache POI für die Excel-Verarbeitung verwenden, müssen wir zuerst die Bibliothek installieren. Die Installation von Apache POI ist relativ einfach. Sie müssen lediglich die neueste Version des JAR-Pakets herunterladen und zum Klassenpfad des Projekts hinzufügen. Es wird empfohlen, zur Einführung von POI Tools wie Maven oder Gradle zu verwenden, um Ausnahmen aufgrund von Versionskonflikten und anderen Problemen zu vermeiden.
3. Excel-Dateien lesen
Das Lesen von Excel-Dateien ist einer der grundlegendsten Vorgänge in der Apache POI-Anwendung. Unten finden Sie Beispielcode zum Lesen einer XLSX-Datei.
public static void readXlsx(String filePath) throws IOException {
FileInputStream fis = new FileInputStream(filePath);
XSSFWorkbook workbook = new XSSFWorkbook(fis); // 创建工作簿
XSSFSheet sheet = workbook.getSheetAt(0); // 获取第一个工作表
int rowStartIndex = sheet.getFirstRowNum(); // 获取第一行的行号
int rowEndIndex = sheet.getLastRowNum(); // 获取最后一行的行号
for (int i = rowStartIndex; i <= rowEndIndex; i++) { // 循环行
XSSFRow row = sheet.getRow(i); // 获取当前行
if (row == null) { // 若为空行则跳过
continue;
}
int cellStartIndex = row.getFirstCellNum(); // 获取第一列的列号
int cellEndIndex = row.getLastCellNum() - 1; // 获取最后一列的列号
for (int j = cellStartIndex; j <= cellEndIndex; j++) { // 循环列
XSSFCell cell = row.getCell(j); // 获取当前单元格
String cellValue = cell.getStringCellValue(); // 获取当前单元格的值
System.out.print(cellValue + " "); // 输出到控制台
}
System.out.println();
}
workbook.close(); // 关闭工作簿
fis.close(); // 关闭输入流
}In diesem Code verwenden wir zunächst FileInputStream, um die XLSX-Datei zu öffnen und verwenden XSSFWorkbook, um die Arbeitsmappe zu erstellen. Anschließend nehmen wir das erste Arbeitsblatt und verwenden eine Schleife, um den Inhalt der Datei Zeile für Zeile und Spalte für Spalte zu lesen und den Wert jeder Zelle an die Konsole auszugeben. Schließlich müssen wir die Arbeitsmappe und den Eingabestream schließen, um Ressourcen freizugeben.
Das Lesen von XLS-Dateien ist im Grunde dasselbe wie das Lesen von XLSX-Dateien. Sie müssen nur den XSSF-bezogenen Code in HSSF ändern.
4. Schreiben in Excel-Dateien
Das Schreiben in Excel-Dateien ist ebenfalls einer der häufigsten Vorgänge in Apache POI-Anwendungen. Unten finden Sie Beispielcode, der in eine XLSX-Datei schreibt.
public static void writeXlsx(String filePath) throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook(); // 创建工作簿
XSSFSheet sheet = workbook.createSheet("Sheet1"); // 创建工作表
XSSFRow row0 = sheet.createRow(0); // 创建第一行
XSSFCell cell00 = row0.createCell(0); // 创建第一个单元格
cell00.setCellValue("姓名"); // 设置单元格的值
XSSFCell cell01 = row0.createCell(1); // 创建第二个单元格
cell01.setCellValue("年龄"); // 设置单元格的值
XSSFRow row1 = sheet.createRow(1); // 创建第二行
XSSFCell cell10 = row1.createCell(0); // 创建第一个单元格
cell10.setCellValue("张三"); // 设置单元格的值
XSSFCell cell11 = row1.createCell(1); // 创建第二个单元格
cell11.setCellValue(20); // 设置单元格的值
XSSFRow row2 = sheet.createRow(2); // 创建第三行
XSSFCell cell20 = row2.createCell(0); // 创建第一个单元格
cell20.setCellValue("李四"); // 设置单元格的值
XSSFCell cell21 = row2.createCell(1); // 创建第二个单元格
cell21.setCellValue(25); // 设置单元格的值
FileOutputStream fos = new FileOutputStream(filePath);
workbook.write(fos); // 输出文件
workbook.close(); // 关闭工作簿
fos.close(); // 关闭输出流
}In diesem Code erstellen wir eine XLSX-Datei und erstellen darin ein Blatt mit dem Namen „Sheet1“. Als Nächstes fügten wir der Tabelle drei Datenzeilen hinzu, wobei jede Zeile zwei Zellen enthielt. Abschließend geben wir die Datei im angegebenen Dateipfad aus und schließen die Arbeitsmappe und den Ausgabestream, um Ressourcen freizugeben.
Das Schreiben von XLS-Dateien ist im Grunde dasselbe wie das Schreiben von XLSX-Dateien. Sie müssen nur den XSSF-bezogenen Code in HSSF ändern.
5. Zusammenfassung
Durch die Erläuterung dieses Artikels können Leser ein vorläufiges Verständnis der Verwendung von Apache POI in der Java-API-Entwicklung erlangen, insbesondere seiner Anwendung bei der Excel-Dateiverarbeitung. Unabhängig davon, ob Excel-Dateien gelesen oder geschrieben werden, bietet Apache POI eine benutzerfreundliche Oberfläche, die es Java-Programmierern ermöglicht, Excel-Dateien problemlos zu bedienen. Gleichzeitig unterstützt Apache POI auch die Verarbeitung von Office-Dateien wie Word und PowerPoint und ist eine unverzichtbare Werkzeugbibliothek für Java-Entwickler.
Das obige ist der detaillierte Inhalt vonVerwendung von Apache POI für die Excel-Verarbeitung in der Java-API-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
