Apache POI - Excel-Datei einlesen

Mit dem Java-Framework Apache POI kann man recht komfortabel Microsoft Excel-Dateien auslesen und erzeugen (schreiben).

Hier ein vollständiges Beispiel zum Auslesen des Tabelleninhaltes einer beliebigen Excel-Datei. Das heißt, wir mit diesem Code das binäre Format (.xls) sowie das auf XML basierende Format .xslx einlesen.

Diese Klasse wurde mit der Apache License 2.0 veröffentlicht:

• Apache License 2.0 (Original)
• Apache License 2.0 (Deutsche Übersetzung)

Excel-Datei einlesen

/*
 * ExcelFileReader.java
 *
 * Copyright (c) 2019 Gernot Segieth - wiki.byte-welt.net
 * 
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.poi.EncryptedDocumentException;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.WorkbookUtil;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

/**
 * ExcelFileProxy liest die Excel-Datei ein und erzeugt ein tabellarisches
 * Abbild der Arbeitsmappe in Form von verschachtelten Listen.
 *
 * @author Gernot Segieth
 */
public class ExcelFileProxy {

    private File excelFile;
    private Workbook workbook;
    private FormulaEvaluator evaluator;
    private boolean isEmptyRow;

    /**
     * Erzeugt einen neuen Excel-Datei-Stellvertreter. ExcelFileProxy liest die
     * ihm übergebene Excel-Datei ein und erzeugt ein tabellarisches Abbild
     * davon.
     *
     * @param excelFile Die einzulesene Excel-Datei
     * @throws java.lang.ClassNotFoundException wenn eine Klasse nicht gefunden
     * wurde
     * @throws java.io.IOException wenn die Datei nicht eingelesen werde konnte
     * @throws org.apache.poi.openxml4j.exceptions.InvalidFormatException wenn
     * es Probleme mit dem Format der Datei oder der Verschlüsselung gibt
     */
    public ExcelFileProxy(File excelFile) throws ClassNotFoundException, IOException, InvalidFormatException {
        this.excelFile = excelFile;
        createWorkbook(excelFile);
    }

    /**
     * Gibt den Inhalt des übergebenen Tabellenblattes in einer geschachtelten
     * Liste zurück.
     *
     * @param sheetIndex der Index des Tabellenblattes
     * @return eine Liste aus Listen (Zeilen mit Spalten)
     */
    public List<List<?>> getSheetContent(int sheetIndex) {
        evaluator = workbook.getCreationHelper().createFormulaEvaluator();
        return getSheetContent(sheetIndex, 0, 0, 0, 0);
    }

    /**
     * Gibt den Inhalt des übergebenen Tabellenblattes in einer geschachtelten
     * Liste zurück.
     *
     * @param sheetIndex der Index des Tabellenblattes
     * @param firstRow in dieser Zeile mit dem Auslesen beginnen
     * @param firstCol in dieser Spalte mit dem Auslesen beginnen
     * @param lastRow letzte auszulesene Zeile
     * @param lastCol letzte auszulesene Spalte
     * @return eine Liste aus Listen (Zeilen mit Spalten)
     */
    public List<List<?>> getSheetContent(int sheetIndex, int firstRow, int firstCol, int lastRow, int lastCol) {
        evaluator = workbook.getCreationHelper().createFormulaEvaluator();
        Sheet sheet = workbook.getSheetAt(sheetIndex);
        List<List<?>> sheetData = new ArrayList<>();

        // Range festlegen (bei Übergabe 0 - ermitteln, sonst Range verarbeiten
        int lastRowNum;
        if (lastRow < 1) {
            lastRowNum = sheet.getLastRowNum();
        } else {
            lastRowNum = lastRow;
        }

        for (int actuallyRow = firstRow; actuallyRow <= lastRowNum; actuallyRow++) {

            Row row = sheet.getRow(actuallyRow); //leere Zeile kann NPE auslösen!

            if (row != null) {  //leere Zeile abfangen
                List<Object> rowData = new ArrayList<>();
                isEmptyRow = true; //Zeile erstmal als leer ansehen

                int lastColNum;
                if (lastCol < 1) {
                    lastColNum = row.getLastCellNum();
                } else {
                    lastColNum = lastCol;
                }

                for (int actuallyCol = firstCol; actuallyCol < lastColNum; actuallyCol++) {
                    Cell cell = row.getCell(actuallyCol);
                    rowData.add(getData(cell));
                }
                if (!isEmptyRow) { //leere Zeilen nicht aufnehmen
                    sheetData.add(rowData);
                }
            }
        }
        return sheetData;
    }

    /**
     * Schreibt Daten einer tabellenartig aufgebauten Liste in das Arbeitsblatt.
     *
     * @param sheetData die Daten aus der Liste, die in das Tabellenblatt
     * geschrieben werden sollen
     * @param sheetName Name des Tabellenblattes
     */
    public void setSheetContent(List<List<?>> sheetData, String sheetName) {
        String safeName = WorkbookUtil.createSafeSheetName(sheetName);
        CreationHelper createHelper = workbook.getCreationHelper();
        Sheet sheet = workbook.createSheet(safeName);

        for (int i = 0, j = sheetData.size(); i < j; i++) {
            Row row = sheet.createRow(i); //Zeile erzeugen
            List<?> rowList = sheetData.get(i); //Zeile holen
            for (int x = 0, y = rowList.size(); x < y; x++) {
                Cell cell = row.createCell(x); //Zelle erzeugen

                Object cellValue = rowList.get(x);
                if (cellValue instanceof Number) {
                    cell.setCellValue((Double) cellValue);
                } else if (cellValue instanceof Date) {
                    cell.setCellValue((Date) cellValue);
                } else if (cellValue instanceof Boolean) {
                    cell.setCellValue((Boolean) cellValue);
                } else if (cellValue instanceof String) {
                    cell.setCellValue(createHelper.createRichTextString(cellValue.toString()));
                }
            }
        }

    }

    /**
     * Gibt die Namen aller Tabellenblätter zurück.
     *
     * @return die Namen der Tabellenblätter
     */
    public String[] getSheetNames() {
        String[] sheetNames = new String[getNumberOfSheets()];
        for (int i = 0; i < sheetNames.length; i++) {
            sheetNames[i] = getSheetName(i);
        }
        return sheetNames;
    }

    /**
     * Gibt die Anzahl der Tabellenblätter in der Excel-Datei zurück.
     *
     * @return die Anzahl
     */
    public int getNumberOfSheets() {
        return workbook.getNumberOfSheets();
    }

    /**
     * Gibt den Namen des Tabellenblattes am übergebenen Index zurück.
     *
     * @param sheetIndex der Index
     * @return das Tabelleenblatt
     */
    public String getSheetName(int sheetIndex) {
        return workbook.getSheetName(sheetIndex);
    }

    /**
     * Setzt den Namen des Tabellenblattes am übergebenen Index.
     *
     * @param index der Index des Tabellenblattes in der Arbeitsmappe
     * @param sheetName der Name des Tabellenblattes
     */
    public void setSheetName(int index, String sheetName) {
        workbook.setSheetName(index, sheetName);
    }

    /**
     * Gibt den Index des aktiven Tabellenblattes zurück.
     *
     * @return der Index des aktiven Tabellenblattes
     */
    public int getActiveSheetIndex() {
        return workbook.getActiveSheetIndex();
    }

    /**
     * Setzt das aktive Tabellenblatt.
     *
     * @param index der Index des aktiven Tabellenblattes in der Arbeitsmappe
     */
    public void setActiveSheet(int index) {
        workbook.setActiveSheet(index);
    }

    /**
     * Gibt das Datum der letzten Änderung der Excel-Datei zurück.
     *
     * @return
     */
    public long lastModified() {
        return excelFile.lastModified();
    }

    /**
     * Gibt den genauen (einzigen) Pfad zur geladenen Excel-Datei zurück.
     *
     * @return Der Pfad zur geladenen Excel-Datei. //@throws java.io.IOException
     */
    public String getPath() /*throws IOException*/ {
        return excelFile.getAbsolutePath();
    }

    /**
     * Setzt den Pfad zur Excel-Datei und erzeugt ein Abbild des Workbooks (alle
     * Tabellenblätter).
     *
     * @param excelFile
     * @throws java.lang.ClassNotFoundException
     * @throws java.io.IOException
     * @throws org.apache.poi.openxml4j.exceptions.InvalidFormatException
     */
    public void setPath(File excelFile) throws ClassNotFoundException, IOException, InvalidFormatException {
        this.excelFile = excelFile;
        update();
    }

    /**
     * Liest das Workbook der Excel-Datei neu ein.
     *
     * @throws java.lang.ClassNotFoundException
     * @throws java.io.IOException
     * @throws org.apache.poi.openxml4j.exceptions.InvalidFormatException
     */
    public synchronized void update() throws ClassNotFoundException, IOException, InvalidFormatException {
        createWorkbook(excelFile);
    }

    public void createWorkbook(Map<String, List<List<?>>> sheetData) throws IOException {
        Set<String> keys = sheetData.keySet();
        Iterator<String> it = keys.iterator();
        while (it.hasNext()) {
            String key = it.next();
            this.setSheetContent(sheetData.get(key), key);
        }
        createExcelFile(excelFile);
    }

    //erzeugt ein Workbook aus der übergebenen Excel-Datei
    private void createWorkbook(File file) throws ClassNotFoundException, IOException, InvalidFormatException {
        String filename = file.getName().toLowerCase();
        try {
            if (filename.endsWith(".xls")) {
                readHSSFWorkbook(file);
                //workbook = WorkbookFactory.create(file);
            } else if (filename.endsWith(".xlsx")) {
                readXSSFWorkbook(file);
            } else {
                throw new IllegalArgumentException("Ausnahmefehler: Die übergebene Datei " + file.getName() + " ist keine valide Microsoft Excel-Datei (*.xls bzw. *.xlsx)!");
            }
        } catch (IOException ioe) {
            Logger.getLogger(ExcelFileProxy.class.getName()).log(Level.SEVERE, null, ioe);
            throw new IOException("Ausnahmefehler: Die Datei " + file.getName() + " konnte nicht eingelesen werden!");
        } catch (EncryptedDocumentException ede) {
            Logger.getLogger(ExcelFileProxy.class.getName()).log(Level.SEVERE, null, ede);
            throw new EncryptedDocumentException("Ausnahmefehler: Die Datei " + file.getName() + " ist mit einem Passwort geschützt und kann daher nicht geöffnet werden!");
        } catch (NoClassDefFoundError err) {
            System.err.println(err.toString());
            throw new ClassNotFoundException("Schwerer Ausnahmefehler: Klassendefinition nicht gefunden!\nPrüfen Sie die Programmdateien und externen Bibliotheken auf Vollständigkeit!");
        }

    }

    private void readHSSFWorkbook(File file) throws IOException {
        POIFSFileSystem fs = new POIFSFileSystem(file);
        workbook = new HSSFWorkbook(fs.getRoot(), true);
        fs.close();
    }

    private void readXSSFWorkbook(File file) throws InvalidFormatException, IOException {
        OPCPackage pkg = OPCPackage.open(file);
        workbook = new XSSFWorkbook(pkg);
        pkg.close();
    }

    //Schreibt eine Arbeitsmappe in eine Exceldatei
    private void createExcelFile(File file) throws FileNotFoundException, IOException {
        try (FileOutputStream fileOut = new FileOutputStream(file)) {
            workbook.write(fileOut);
        } catch (FileNotFoundException fnfe) {
            throw new IOException("Ausnahmefehler: Die Datei " + file.getName() + " konnte nicht erzeugt werden!");
        } catch (IOException ioe) {
            throw new IOException("Ausnahmefehler: Die Datei " + file.getName() + " konnte nicht erzeugt werden!");
        }
    }

    //Liest die Daten aus einer Zelle und gibt sie zurück.
    private Object getData(Cell cell) {
        if (cell != null) {

            switch (cell.getCellType()) {
                case STRING:
                    String string = cell.getRichStringCellValue().getString();
                    if (string.isEmpty()) {
                        return null;
                    } else {
                        isEmptyRow = false;
                        return string.trim();
                    }
                case NUMERIC:
                    if (DateUtil.isCellDateFormatted(cell)) {
                        Date date = cell.getDateCellValue();
                        if (date.toString().isEmpty()) {
                            return null;
                        } else {
                            isEmptyRow = false;
                            return date;
                        }
                    } else {
                        Number number = cell.getNumericCellValue();
                        if (number.toString().isEmpty()) {
                            return null;
                        } else {
                            isEmptyRow = false;
                            return number;
                        }
                    }

                case BOOLEAN:
                    Boolean bool = (cell.getBooleanCellValue());
                    if (bool.toString().isEmpty()) {
                        return null;
                    } else {
                        isEmptyRow = false;
                        return bool;
                    }

                case _NONE:
                case FORMULA:
                case BLANK:
                case ERROR:
                default:
                    return null;
            }
        } else {
            return null;
        }
    }
}

Erläuterungen zum Code

Dieser Beitrag wird derzeit noch bearbeitet. Der Text ist deshalb unvollständig und kann Fehler oder ungeprüfte Aussagen enthalten.