API Java Open Source pour les fichiers Microsoft^® Excel XLSX

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.

<!-- 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

1. Créez un nouveau SXSSFWorkbook et conservez 100 lignes en mémoire, les lignes en excès seront vidées sur le disque
2. Créer une nouvelle feuille de calcul en utilisant la méthode createSheet()
3. 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
4. Enregistrez le fichier à l'aide de FileOutputStream() et transmettez le nom du fichier de sortie
5. Écrire dans le fichier à l'aide de la méthode SXSSFWorkbook.Write() et passer FileOutputStream en tant que paramètre

// 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.

// 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.

// 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();

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.