![](https://products-qa.fileformat.com/fr/spreadsheet/java/apache-poi-xssf/header-image.png)
Apache POI-XSSF
API Java Open Source pour les fichiers Microsoft® Excel XLSX
Créez, modifiez et convertissez des feuilles de calcul Excel XLSX aux formats de fichier CSV et HTML via la bibliothèque Java.
Qu'est-ce qu'Apache POI-XSSF ?
Apache POI-XSSF est une implémentation Java pure du format de fichier Excel 2007 XLSX. L'API fournit des procédures pour créer, lire, modifier et écrire des fichiers Excel XLSX. Il fournit des structures de bas niveau pour les personnes ayant des besoins spéciaux. Il fournit également une API de modèle d'événement pour un accès en lecture seule efficace ainsi qu'une API de modèle utilisateur complet pour créer, lire et modifier des fichiers XLSX. Apache POI-XSSF offre une excellente prise en charge des fonctionnalités Excel supplémentaires telles que l'utilisation de feuilles, de formules, la création de styles de cellule en remplissant les couleurs et les bordures, les polices, les en-têtes et les pieds de page, les formes, les validations de données, les images, les hyperliens et bien d'autres.
Premiers pas avec Apache POI XSSF
Tout d'abord, vous devez avoir le kit de développement Java (JDK) installé sur votre système. Si vous l'avez déjà, rendez-vous sur la page de téléchargement d'Apache POI pour obtenir la dernière version stable dans une archive. Extrayez le contenu du fichier ZIP dans n'importe quel répertoire à partir duquel les bibliothèques requises peuvent être liées à votre programme Java. C'est tout!
Référencer Apache POI dans votre projet Java basé sur Maven est encore plus simple. Tout ce dont vous avez besoin est d'ajouter la dépendance suivante dans votre pom.xml et de laisser votre IDE récupérer et référencer les fichiers Apache POI Jar.
Dépendance Apache POI Maven
<!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>4.1.0</version>
</dependency>
Créer de grandes feuilles de calcul Excel à l'aide de l'API Java
Apache POI XSSF offre une faible empreinte mémoire via l'API SXSSF pour gérer l'écriture de données volumineuses dans des fichiers MS Excel. Cela permet d'écrire des fichiers très volumineux sans manquer de mémoire car seule une partie configurable des lignes est conservée en mémoire à tout moment. POI-SXSSF atteint sa faible empreinte mémoire en limitant l'accès aux lignes qui se trouvent dans une fenêtre glissante, tandis que XSSF donne accès à toutes les lignes du document. Les lignes plus anciennes qui ne sont plus dans la fenêtre deviennent inaccessibles, car elles sont écrites sur le disque. Vous pouvez créer un gros fichier Excel en Java en suivant les étapes suivantes
Créer un gros fichier Excel à l'aide de Java
- Créez un nouveau SXSSFWorkbook et conservez 100 lignes en mémoire, les lignes en excès seront vidées sur le disque
- Créer une nouvelle feuille de calcul en utilisant la méthode createSheet()
- Insérez des données dans 2000 lignes et 2000 cellules en utilisant createRow(), createCell() et setCellValue("Vos données") à l'intérieur et une boucle imbriquée
- Enregistrez le fichier à l'aide de FileOutputStream() et transmettez le nom du fichier de sortie
- Écrire dans le fichier à l'aide de la méthode SXSSFWorkbook.Write() et passer FileOutputStream en tant que paramètre
Créer un gros fichier Excel
// 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();
API Java pour la création de classeurs Excel et l'ajout de feuilles
Apache POI XSSF permet aux programmeurs informatiques de créer un nouveau classeur Excel au format de fichier XLSX. Une fois que les développeurs ont créé le classeur, les feuilles de calcul sont créées à partir d'une instance existante du classeur et la feuille nouvellement créée est automatiquement ajoutée en séquence au classeur.
Créer un classeur Excel et ajouter des feuilles
// 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);
Convertir une feuille de calcul Excel en CSV et autre format de fichier
Les développeurs et programmeurs Java peuvent facilement convertir une feuille de calcul Excel en un format de fichier CSV à l'aide de l'API Apache POI XSSF. CSV signifie Comma-Separated-Values et est un format très courant utilisé pour échanger des données entre de nombreuses applications. Tout d'abord, les développeurs doivent lire le fichier XLS d'entrée à l'aide de l'API Apache POI XSSF, puis écrire les informations extraites dans des fichiers CSV.
Convertir XLSX en 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();
Amélioration XSSF pour les en-têtes et pieds de page
Apache POI XSSF a la capacité de gérer les en-têtes et pieds de page de la première page, ainsi que les en-têtes et pieds de page pairs/impairs. Les en-têtes et les pieds de page sont une partie très importante d'une feuille de calcul Excel. Il contient généralement des informations supplémentaires telles que les dates, les numéros de page, le nom de l'auteur et les notes de bas de page, qui aident à garder les documents plus longs organisés et plus faciles à lire. Tous les indicateurs de propriété d'en-tête/pied de page peuvent être gérés dans XSSF. L'en-tête et le pied de page impairs sont l'en-tête et le pied de page par défaut. Il est affiché sur toutes les pages qui n'affichent ni en-tête de première page ni en-tête de page paire.
Fusion de cellules et extraction de texte dans des fichiers Excel XLSX
Apache POI XSSF fournit la capacité qui permet aux programmeurs Java de fusionner plusieurs cellules en une seule cellule dans une feuille de calcul Excel. Il a inclus des méthodes qui prennent les index de cellule comme argument et fusionnent les cellules en une seule grande cellule. L'une des fonctionnalités les plus exigeantes est la possibilité d'extraire du texte d'un fichier XLSX et de l'utiliser selon vos besoins. Apache POI a fourni une extraction de texte de base pour tous les formats de fichiers pris en charge par le projet. Pour les besoins d'extraction de texte avancés, y compris l'extraction de texte enrichi (comme le formatage et le style), ainsi que la sortie XML et HTML, Apache POI travaille en étroite collaboration avec Apache Tika pour fournir des analyseurs Tika alimentés par POI pour tous les formats de fichiers pris en charge par le projet.