![](https://products-qa.fileformat.com/nl/spreadsheet/java/apache-poi-xssf/header-image.png)
Apache POI-XSSF
Open Source Java API voor Microsoft® Excel XLSX-bestanden
Maak, bewerk en converteer Excel XLSX-spreadsheets naar CSV- en HTML-bestandsindelingen via Java Library.
Wat is Apache POI-XSSF?
Apache POI-XSSF is een pure Java-implementatie van het Excel 2007 XLSX-bestandsformaat. De API biedt procedures voor het maken, lezen, wijzigen en schrijven van Excel XLSX-bestanden. Het biedt low-level structuren voor mensen met speciale behoeften. Het biedt ook een gebeurtenismodel-API voor efficiënte alleen-lezen toegang, evenals een volledige gebruikersmodel-API voor het maken, lezen en wijzigen van XLSX-bestanden. Apache POI-XSSF biedt geweldige ondersteuning voor extra Excel-functies, zoals werken met werkbladen, formules, het maken van celstijlen door kleuren en randen, lettertypen, kop- en voetteksten, vormen, gegevensvalidaties, afbeeldingen, hyperlinks en nog veel meer.
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.
Apache POI Maven-afhankelijkheid
<!-- 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
- Maak een nieuwe SXSSFWorkbook en bewaar 100 rijen in het geheugen, meer dan rijen worden naar schijf gewist
- Maak een nieuw werkblad met de methode createSheet()
- Voeg gegevens in 2000 rijen en 2000 cellen in met behulp van createRow(), createCell() en setCellValue("Uw gegevens") binnenin en een geneste lus
- Sla het bestand op met FileOutputStream() en geef de naam van het uitvoerbestand door
- Schrijf naar bestand met de methode SXSSFWorkbook.Write() en geef FileOutputStream door als parameter
Een groot Excel-bestand maken
// 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.
Excel-werkmap maken en bladen toevoegen
// 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.
Converteer XLSX naar CSV
// 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();
XSSF-verbetering voor kop- en voetteksten
Apache POI XSSF heeft de mogelijkheid om kop- en voetteksten op de eerste pagina te verwerken, evenals kop- en voetteksten even/oneven. Kop- en voetteksten zijn een zeer belangrijk onderdeel van een Excel-spreadsheet. Het bevat meestal extra informatie, zoals datums, paginanummers, de naam van de auteur en voetnoten, die helpen om langere documenten overzichtelijk en beter leesbaar te houden. Alle Header/Footer Property-vlaggen kunnen worden verwerkt in XSSF. De oneven kop- en voettekst zijn de standaard kop- en voetteksten. Het wordt weergegeven op alle pagina's die geen kop van de eerste pagina of kop van even pagina's weergeven.
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.