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 können mit folgendem 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 ExcelFileReader {

    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 ExcelFileReader(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.

Fragen

Das Thema wurde nicht ausreichend behandelt? Du hast Fragen dazu und brauchst weitere Informationen? Lass Dir von uns helfen!

• Besuche uns im Byte-Welt-Forum
• Besuche unseren Chat

Wir helfen dir gerne!

Dir hat dieser Artikel gefallen? Oder Du hast Fehler entdeckt und möchtest zur Berichtigung beitragen? Prima! Schreibe einen Kommentar!

Du musst angemeldet sein, um einen Kommentar abzugeben.