Arbeiten mit Microsoft Excel in Java

Arbeiten mit Microsoft Excel in Java

1. Einführung

In diesem Tutorial werden wir die Verwendung vonApache POI and JExcel APIs for working with Excel spreadsheets demonstrieren.

Beide Bibliotheken können zum dynamischen Lesen, Schreiben und Ändern des Inhalts einer Excel-Tabelle verwendet werden und bieten eine effektive Möglichkeit, Microsoft Excel in eine Java-Anwendung zu integrieren.

2. Maven-Abhängigkeiten

Zu Beginn müssen wir unsererpom.xml-Datei die folgenden Abhängigkeiten hinzufügen:


    org.apache.poi
    poi
    3.15


    org.apache.poi
    poi-ooxml
    3.15

Die neuesten Versionen vonpoi-ooxml undjxls-jexcel können von Maven Central heruntergeladen werden.

3. Apache POI

Apache POI library supports both .xls and .xlsx files und ist eine komplexere Bibliothek als andere Java-Bibliotheken für die Arbeit mit Excel-Dateien.

Es bietet dieWorkbook-Schnittstelle zum Modellieren einerExcel-Datei und dieSheet-,Row- undCell-Schnittstellen, die die Elemente einer Excel-Datei als modellieren sowie Implementierungen jeder Schnittstelle für beide Dateiformate.

Wenn Sie mit dem neueren Dateiformat.xlsxarbeiten, verwenden Sie die Klassen. vonXSSFWorkbook, XSSFSheet, XSSFRow, and XSSFCell

Verwenden Sie die KlassenHSSFWorkbook, HSSFSheet, HSSFRow, undHSSFCell., um mit dem älteren.xls-Format zu arbeiten

3.1. Lesen aus Excel

Erstellen wir eine Methode, die eine.xlsx-Datei öffnet und dann den Inhalt aus dem ersten Blatt der Datei liest.

Die Methode zum Lesen des Zelleninhalts hängt vom Typ der Daten in der Zelle ab. Der Typ des Zelleninhalts kann unter Verwendung dergetCellTypeEnum()-Methode derCell-Schnittstelle bestimmt werden.

Öffnen Sie zunächst die Datei von einem bestimmten Speicherort aus:

FileInputStream file = new FileInputStream(new File(fileLocation));
Workbook workbook = new XSSFWorkbook(file);

Als nächstes rufen wir das erste Blatt der Datei ab und durchlaufen jede Zeile:

Sheet sheet = workbook.getSheetAt(0);

Map> data = new HashMap<>();
int i = 0;
for (Row row : sheet) {
    data.put(i, new ArrayList());
    for (Cell cell : row) {
        switch (cell.getCellTypeEnum()) {
            case STRING: ... break;
            case NUMERIC: ... break;
            case BOOLEAN: ... break;
            case FORMULA: ... break;
            default: data.get(new Integer(i)).add(" ");
        }
    }
    i++;
}

Apache POI has different methods for reading each type of data. Lassen Sie uns den Inhalt der einzelnen Schalterfälle oben erweitern.

Wenn der Aufzählungswert für den ZelltypSTRING ist, wird der Inhalt mit der MethodegetRichStringCellValue() derCell-Schnittstelle gelesen:

data.get(new Integer(i)).add(cell.getRichStringCellValue().getString());

Zellen mit dem InhaltstypNUMERICkönnen entweder ein Datum oder eine Zahl enthalten und werden auf folgende Weise gelesen:

if (DateUtil.isCellDateFormatted(cell)) {
    data.get(i).add(cell.getDateCellValue() + "");
} else {
    data.get(i).add(cell.getNumericCellValue() + "");
}

FürBOOLEAN Werte haben wir diegetBooleanCellValue() Methode:

data.get(i).add(cell.getBooleanCellValue() + "");

Und wenn der ZelltypFORMULA ist, können wir die MethodegetCellFormula() verwenden:

data.get(i).add(cell.getCellFormula() + "");

3.2. Schreiben in Excel

Apache POI verwendet dieselben Schnittstellen wie im vorherigen Abschnitt zum Schreiben in eine Excel-Datei und bietet eine bessere Unterstützung für das Stylen als JExcel.

Erstellen wir eine Methode, mit der eine Personenliste in ein Blatt mit dem Titel“Persons” geschrieben wird. Zuerst erstellen und formatieren wir eine Kopfzeile, die“Name” und“Age” Zellen enthält:

Workbook workbook = new XSSFWorkbook();

Sheet sheet = workbook.createSheet("Persons");
sheet.setColumnWidth(0, 6000);
sheet.setColumnWidth(1, 4000);

Row header = sheet.createRow(0);

CellStyle headerStyle = workbook.createCellStyle();
headerStyle.setFillForegroundColor(IndexedColors.LIGHT_BLUE.getIndex());
headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);

XSSFFont font = ((XSSFWorkbook) workbook).createFont();
font.setFontName("Arial");
font.setFontHeightInPoints((short) 16);
font.setBold(true);
headerStyle.setFont(font);

Cell headerCell = header.createCell(0);
headerCell.setCellValue("Name");
headerCell.setCellStyle(headerStyle);

headerCell = header.createCell(1);
headerCell.setCellValue("Age");
headerCell.setCellStyle(headerStyle);

Als nächstes schreiben wir den Inhalt der Tabelle in einem anderen Stil:

CellStyle style = workbook.createCellStyle();
style.setWrapText(true);

Row row = sheet.createRow(2);
Cell cell = row.createCell(0);
cell.setCellValue("John Smith");
cell.setCellStyle(style);

cell = row.createCell(1);
cell.setCellValue(20);
cell.setCellStyle(style);

Zum Schluss schreiben wir den Inhalt in eine‘temp.xlsx'-Datei im aktuellen Verzeichnis und schließen die Arbeitsmappe:

File currDir = new File(".");
String path = currDir.getAbsolutePath();
String fileLocation = path.substring(0, path.length() - 1) + "temp.xlsx";

FileOutputStream outputStream = new FileOutputStream(fileLocation);
workbook.write(outputStream);
workbook.close();

Testen wir die oben genannten Methoden in einemJUnit-Test, bei dem Inhalte in dietemp.xlsx-Datei geschrieben und dann dieselbe Datei gelesen werden, um zu überprüfen, ob sie den von uns geschriebenen Text enthält:

public class ExcelTest {

    private ExcelPOIHelper excelPOIHelper;
    private static String FILE_NAME = "temp.xlsx";
    private String fileLocation;

    @Before
    public void generateExcelFile() throws IOException {
        File currDir = new File(".");
        String path = currDir.getAbsolutePath();
        fileLocation = path.substring(0, path.length() - 1) + FILE_NAME;

        excelPOIHelper = new ExcelPOIHelper();
        excelPOIHelper.writeExcel();
    }

    @Test
    public void whenParsingPOIExcelFile_thenCorrect() throws IOException {
        Map> data
          = excelPOIHelper.readExcel(fileLocation);

        assertEquals("Name", data.get(0).get(0));
        assertEquals("Age", data.get(0).get(1));

        assertEquals("John Smith", data.get(1).get(0));
        assertEquals("20", data.get(1).get(1));
    }
}

4. JExcel

Die JExcel-Bibliothek ist eine kompakte Bibliothek mit dem Vorteil, dass sie einfacher zu verwenden ist als Apache POI, jedoch mit dem Nachteil, dass sie nur die Verarbeitung von Excel-Dateien im Format.xls (1997-2003) unterstützt.

Derzeit werden.xlsx Dateien nicht unterstützt.

4.1. Lesen aus Excel

Um mit Excel-Dateien arbeiten zu können, bietet diese Bibliothek eine Reihe von Klassen, die die verschiedenen Teile einer Excel-Datei darstellen. The Workbook class represents the entire collection of sheets. Die KlasseSheet repräsentiert ein einzelnes Blatt, und die KlasseCell repräsentiert eine einzelne Zelle einer Tabelle.

Schreiben wir eine Methode, die eine Arbeitsmappe aus einer angegebenen Excel-Datei erstellt, das erste Blatt der Datei abruft, den Inhalt durchläuft und jede Zeile inHashMap hinzufügt:

public class JExcelHelper {

    public Map> readJExcel(String fileLocation)
      throws IOException, BiffException {

        Map> data = new HashMap<>();

        Workbook workbook = Workbook.getWorkbook(new File(fileLocation));
        Sheet sheet = workbook.getSheet(0);
        int rows = sheet.getRows();
        int columns = sheet.getColumns();

        for (int i = 0; i < rows; i++) {
            data.put(i, new ArrayList());
            for (int j = 0; j < columns; j++) {
                data.get(i)
                  .add(sheet.getCell(j, i)
                  .getContents());
            }
        }
        return data;
    }
}

4.2. Schreiben in Excel

Zum Schreiben in eine Excel-Datei bietet die JExcel-Bibliothek ähnliche Klassen wie die oben verwendeten, die eine Tabellenkalkulationsdatei modellieren:WritableWorkbook,WritableSheet undWritableCell.

The WritableCell class has subclasses corresponding to the different types of content, die geschrieben werden können:Label,DateTime,Number,Boolean,Blank undFormula.

Diese Bibliothek bietet auch Unterstützung für grundlegende Formatierungen, z. B. die Steuerung von Schriftart, Farbe und Zellenbreite.

Schreiben wir eine Methode, die eine Arbeitsmappe mit dem Namen‘temp.xls' im aktuellen Verzeichnis erstellt, und schreiben dann denselben Inhalt, den wir im Abschnitt Apache POI geschrieben haben.

Lassen Sie uns zunächst die Arbeitsmappe erstellen:

File currDir = new File(".");
String path = currDir.getAbsolutePath();
String fileLocation = path.substring(0, path.length() - 1) + "temp.xls";

WritableWorkbook workbook = Workbook.createWorkbook(new File(fileLocation));

Als nächstes erstellen wir das erste Blatt und schreiben den Header der Excel-Datei, der die Zellen“Name” und“Age” enthält:

WritableSheet sheet = workbook.createSheet("Sheet 1", 0);

WritableCellFormat headerFormat = new WritableCellFormat();
WritableFont font
  = new WritableFont(WritableFont.ARIAL, 16, WritableFont.BOLD);
headerFormat.setFont(font);
headerFormat.setBackground(Colour.LIGHT_BLUE);
headerFormat.setWrap(true);

Label headerLabel = new Label(0, 0, "Name", headerFormat);
sheet.setColumnView(0, 60);
sheet.addCell(headerLabel);

headerLabel = new Label(1, 0, "Age", headerFormat);
sheet.setColumnView(0, 40);
sheet.addCell(headerLabel);

Schreiben wir mit einem neuen Stil den Inhalt der von uns erstellten Tabelle:

WritableCellFormat cellFormat = new WritableCellFormat();
cellFormat.setWrap(true);

Label cellLabel = new Label(0, 2, "John Smith", cellFormat);
sheet.addCell(cellLabel);
Number cellNumber = new Number(1, 2, 20, cellFormat);
sheet.addCell(cellNumber);

Es ist sehr wichtig, daran zu denken, in die Datei zu schreiben und sie am Ende zu schließen, damit sie von anderen Prozessen verwendet werden kann, wobei die Methodenwrite() undclose()der KlasseWorkbookverwendet werden:

workbook.write();
workbook.close();

5. Fazit

In diesem Lernprogramm wurde veranschaulicht, wie die APIApache POIund die APIJExcelzum Lesen und Schreiben einer Excel-Datei aus einem Java-Programm verwendet werden.

Den vollständigen Quellcode für diesen Artikel finden Sie inGitHub project.