Open Source Java API voor Microsoft^® Excel XLSX-bestanden

Aan de slag met Apache POI XSSF

Allereerst moet u de Java Development Kit (JDK) op uw systeem hebben geïnstalleerd. Als je het al hebt, ga dan naar de Apache POI's download pagina om de laatste stabiele release in een archief te krijgen. Pak de inhoud van het ZIP-bestand uit in een willekeurige map van waaruit de benodigde bibliotheken aan uw Java-programma kunnen worden gekoppeld. Dat is alles!

Verwijzen naar Apache POI in uw op Maven gebaseerde Java-project is nog eenvoudiger. Het enige dat u nodig hebt, is de volgende afhankelijkheid toe te voegen aan uw pom.xml en uw IDE de Apache POI Jar-bestanden te laten ophalen en ernaar te laten verwijzen.

<!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>4.1.0</version>
</dependency>

Maak grote Excel-spreadsheets met behulp van Java API

Apache POI XSSF biedt een lage geheugenvoetafdruk via SXSSF API voor het verwerken van grote gegevens die naar MS Excel-bestanden worden geschreven. Hierdoor kunnen zeer grote bestanden worden geschreven zonder dat het geheugen vol raakt, aangezien slechts een configureerbaar deel van de rijen tegelijkertijd in het geheugen wordt bewaard. POI-SXSSF bereikt zijn lage geheugenvoetafdruk door de toegang tot de rijen binnen een schuifvenster te beperken, terwijl XSSF toegang geeft tot alle rijen in het document. Oudere rijen die niet meer in het venster staan, worden ontoegankelijk, omdat ze naar de schijf worden geschreven. U kunt een groot Excel-bestand in Java maken door de volgende stappen te volgen:

Maak een groot Excel-bestand met Java

1. Maak een nieuwe SXSSFWorkbook en bewaar 100 rijen in het geheugen, meer dan rijen worden naar schijf gewist
2. Maak een nieuw werkblad met de methode createSheet()
3. Voeg gegevens in 2000 rijen en 2000 cellen in met behulp van createRow(), createCell() en setCellValue("Uw gegevens") binnenin en een geneste lus
4. Sla het bestand op met FileOutputStream() en geef de naam van het uitvoerbestand door
5. Schrijf naar bestand met de methode SXSSFWorkbook.Write() en geef FileOutputStream door als parameter

// create a new SXSSFWorkbook
SXSSFWorkbook wb = new SXSSFWorkbook(100);
Sheet sh = wb.createSheet();
// insert 2000 rows
for(int rownum = 0; rownum < 2000; rownum++){
    Row row = sh.createRow(rownum);
    // insert data in 20000 cells
    for(int cellnum = 0; cellnum < 10; cellnum++){
    Cell cell = row.createCell(cellnum);
    cell.setCellValue("Row Number: "+ rownum + " Cell Number: "+ cellnum);
    }
}
// save file
FileOutputStream out = new FileOutputStream("LargeDcument.xlsx");
wb.write(out);
out.close();

Java-API's voor het maken van Excel-werkmappen en het toevoegen van werkbladen

Met Apache POI XSSF kunnen computerprogrammeurs een nieuwe Excel-werkmap maken in XLSX-bestandsindeling. Nadat ontwikkelaars de werkmap hebben gemaakt, worden werkbladen gemaakt op basis van een bestaande instantie van de werkmap en wordt het nieuw gemaakte werkblad automatisch in volgorde aan de werkmap toegevoegd.

// create a new XLSX file
Workbook workbook = new XSSFWorkbook();
OutputStream outputStream = new FileOutputStream("CreateXlsx.xlsx");
// create a new sheet
Sheet sheet = workbook.createSheet("Apache POI XSSF");
// create a new sheet
Row row   = sheet.createRow(1);
// create a new cell
Cell cell  = row.createCell(1);
// set cell value
cell.setCellValue("File Format Developer Guide");
// save file
workbook.write(outputStream);

Converteer een Excel-spreadsheet naar CSV en ander bestandsformaat

Java-ontwikkelaars en programmeurs kunnen eenvoudig een Excel-spreadsheet converteren naar een CSV-bestandsindeling met behulp van Apache POI XSSF API. CSV staat voor Comma-Separated-Values en is een veelgebruikt formaat dat wordt gebruikt voor het uitwisselen van gegevens tussen veel toepassingen. Ten eerste moeten ontwikkelaars het XLS-invoerbestand lezen met de Apache POI XSSF API en vervolgens de geëxtraheerde informatie in CSV-bestanden schrijven.

// Open and existing XLSX file
FileInputStream fileInStream = new FileInputStream("LargeDocument.xlsx");
XSSFWorkbook workBook = new XSSFWorkbook(fileInStream);
XSSFSheet selSheet = workBook.getSheetAt(0);
// Loop through all the rows
Iterator rowIterator = selSheet.iterator();
while (rowIterator.hasNext()) {
    Row row = rowIterator.next();
    // Loop through all rows and add ","
    Iterator cellIterator = row.cellIterator();
    StringBuffer stringBuffer = new StringBuffer();
    while (cellIterator.hasNext()) {
    Cell cell = cellIterator.next();
    if (stringBuffer.length() != 0) {
        stringBuffer.append(",");
    }
    stringBuffer.append(cell.getStringCellValue());
    }
    System.out.println(stringBuffer.toString());
}
workBook.close();

Cellen en tekstextractie samenvoegen in Excel XLSX-bestanden

Apache POI XSSF biedt de mogelijkheid waarmee Java-programmeurs meerdere cellen kunnen samenvoegen tot één cel in een Excel-spreadsheet. Het bevat methoden die celindexen als argument gebruiken en de cellen samenvoegen tot een enkele grote cel. Een van de meest veeleisende functies is de mogelijkheid om tekst uit een XLSX-bestand te extraheren en te gebruiken volgens uw behoeften. Apache POI heeft basistekstextractie geleverd voor alle door het project ondersteunde bestandsindelingen. Voor geavanceerde tekstextractiebehoeften, waaronder Rich Text-extractie (zoals opmaak en opmaak), samen met XML- en HTML-uitvoer, werkt Apache POI nauw samen met Apache Tika om POI-aangedreven Tika-parsers te leveren voor alle door het project ondersteunde bestandsindelingen.