Si vous êtes un développeur d’applications Java travaillant avec Excel à partir de vos applications Java, vous seriez intéressé à fournir les fonctionnalités de la manipulation des données Excel dans votre application. Excel vous permet de formater le style de cellule, de définir le type de cellule sur différents types de données, de remplir une cellule de différentes couleurs, etc. Apache POI sert de pont entre Java et Excel, offrant des outils pour manipuler Excel fichiers XLSX par programme. Dans cette série de blogs, nous dévoilerons l’art de la manipulation des cellules Excel à l’aide d’Apache Poi en Java. Plongeons et découvrons la synergie du code et des feuilles de calcul!

Table des matières

Tout au long du blog, nous allons passer par des échantillons de code et une explication de la même chose pour les éléments suivants:

  1. Création de cellules dans un fichier Excel
  2. Créer des cellules de date dans Excel
  3. Travailler avec différents types de cellules
  4. Réglage de l’apparence cellulaire

Travailler avec les cellules dans un fichier Excel dans Java

Création de cellules dans un fichier Excel

//Create Cells
XSSFWorkbook wb = new XSSFWorkbook();
XSSFCreationHelper createHelper = wb.getCreationHelper();
XSSFSheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(0);
// Create a cell and put a value in it.
Cell cell = row.createCell(0);
cell.setCellValue(1);
row.createCell(1).setCellValue(1.2);
row.createCell(2).setCellValue(createHelper.createRichTextString("This is a string"));
row.createCell(3).setCellValue(true);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

L’extrait de code Java ci-dessus démontre l’utilisation de l’API Apache POI pour travailler avec des cellules dans un classeur Excel. Le code crée un nouveau classeur Excel (\ **xssfworkbook** \), initialise une feuille dans le classeur, puis rempli les cellules avec différents types de données. Tout d’abord, le code crée une nouvelle feuille nommée « Nouvelle feuille ». Il génère ensuite une ligne à l’index 0 sur la feuille et procède pour remplir les cellules dans cette ligne. La première cellule (index 0) se voit attribuer une valeur entière de 1 en utilisant la méthode \ **setCellValue** \. En revanche, la deuxième cellule (Index 1) est définie sur une valeur décimale de 1.2 directement dans la méthode \ **CreateCell** \. La troisième cellule (index 2) contient une valeur de chaîne «Ceci est une chaîne» créée à l’aide de la méthode \ **CreaterichTextString** \ à partir de l’instance \ **xssfcreationhelper** \. Enfin, la quatrième cellule (index 3) est remplie de la valeur booléenne «vraie». Une fois les valeurs de cellule définies, le code écrit le classeur résultant à un fichier Excel nommé «Workbook.xlsx» à l’aide d’un \ **fileoutputStream** \.

Création de types de date Cellule

XSSFWorkbook wb = new XSSFWorkbook();
//Workbook wb = new XSSFWorkbook();
CreationHelper createHelper = wb.getCreationHelper();
org.apache.poi.ss.usermodel.Sheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(0);
// Create a cell and put a date value in it.  The first cell is not styled
// as a date.
Cell cell = row.createCell(0);
cell.setCellValue(new Date());
// we style the second cell as a date (and time).  It is important to
// create a new cell style from the workbook otherwise you can end up
// modifying the built in style and effecting not only this cell but other cells.
CellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(
    createHelper.createDataFormat().getFormat("m/d/yy h:mm"));
cell = row.createCell(1);
cell.setCellValue(new Date());
cell.setCellStyle(cellStyle);
//you can also set date as java.util.Calendar
cell = row.createCell(2);
cell.setCellValue(Calendar.getInstance());
cell.setCellStyle(cellStyle);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

Cet extrait de code Java présente l’utilisation de l’API Apache POI pour travailler avec des cellules de type Date dans un classeur Excel. Le code commence par créer un nouveau classeur Excel (\ **xssfworkbook** \). La première cellule (index 0) est destinée à maintenir une valeur de date. Un objet \ **Date** \ représentant la date et l’heure actuels est défini comme la valeur de la cellule à l’aide de la méthode \ **setCellValue** \. Cette cellule n’est pas explicitement stylée comme une date. Pour la deuxième cellule (Index 1), un nouveau style de cellule (\ cellstyle \) est créé à l’aide de la méthode \ CreateCellStyle \ du classeur. Ce style est ensuite configuré pour avoir un format de date et d’heure spécifique à l’aide de la méthode \ SetDataFormat \. Le \ CreateDataFormat (). GetFormat (« m / d / yy h: mm ») \ Le processus crée un format de date personnalisé avec un modèle de format de «m / d / yy h: mm». La deuxième cellule se voit attribuer la valeur de date et d’heure actuelle, et le style de cellule nouvellement créé s’y est appliqué à l’aide de la méthode \ setCellStyle \. La troisième cellule (Index 2) montre une méthode alternative pour remplir les cellules de type date à l’aide de \ java.util.calendar \. Semblable à la deuxième cellule, le style de cellule personnalisé est également appliqué à cette cellule.

Travailler avec différents types de cellules

XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
Row row = sheet.createRow(2);
row.createCell(0).setCellValue(1.1);
row.createCell(1).setCellValue(new Date());
row.createCell(2).setCellValue(Calendar.getInstance());
row.createCell(3).setCellValue("a string");
row.createCell(4).setCellValue(true);
row.createCell(5).setCellType(CellType.ERROR);		// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

Dans cet échantillon de code, différents styles de cellules sont appliqués aux cellules d’un fichier Excel en utilisant l’API APACH POI comme expliqué dans les étapes suivantes.

  1. Une ligne est créée à l’index 2 sur la feuille en utilisant \ **Createrow** (2) \. Les cellules sont ensuite remplies dans cette ligne avec les données suivantes.
  2. La première cellule (index 0) se voit attribuer une valeur décimale de 1.1 à l’aide de la méthode \ **setCellValue** \.
  3. Dans la deuxième cellule (index 1), la date et l’heure actuelles sont insérées à l’aide d’un objet \ date \ via la méthode \ **setCellValue** \.
  4. La troisième cellule (Index 2) contient la date et l’heure à partir d’une instance de \ calendrier \, définie à l’aide de la méthode \ **setCellValue** \.
  5. La quatrième cellule (index 3) contient le texte «une chaîne».
  6. La cinquième cellule (index 4) est désignée pour une valeur booléenne «vraie».
  7. À l’avenir, un type de cellule spécifique est attribué à la sixième cellule (index 5) en invoquant la méthode \ **setCellType** \. Cette cellule est configurée comme une cellule d’erreur à l’aide de l’énumération \ **CellType.Error** \, ce qui indique qu’il affichera une valeur d’erreur. Enfin, le classeur modifié est écrit dans un fichier nommé «Workbook.xlsx» à l’aide d’un \ **fileoutputStream** \. En résumé, cet exemple de code montre comment établir un classeur Excel, appliquer différents styles de cellules pour s’adapter à divers types de données et, finalement, enregistrer le classeur modifié dans un fichier. Cette illustration pratique présente les capacités de la bibliothèque APACH POI pour travailler avec des fichiers Excel en Java.

Réglage de l’apparence de la cellule

XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(1);
// Aqua background
CellStyle style = wb.createCellStyle();
style.setFillBackgroundColor(IndexedColors.AQUA.getIndex());
style.setFillPattern(FillPatternType.BIG_SPOTS);
Cell cell = row.createCell(1);
cell.setCellValue("X");
cell.setCellStyle(style);
// Orange "foreground", foreground being the fill foreground not the font color.
style = wb.createCellStyle();
style.setFillForegroundColor(IndexedColors.ORANGE.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
cell = row.createCell(2);
cell.setCellValue("X");
cell.setCellStyle(style);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}
wb.close();

Cet extrait de code montre comment manipuler l’apparence des cellules dans un fichier Excel à l’aide de la bibliothèque Apache POI en Java. Ceci est réalisé en utilisant les étapes suivantes.

  1. Une ligne est créée à l’index 1 sur la feuille à l’aide de \ Createrow (1) \. Les modifications suivantes sont apportées aux cellules de cette ligne.
  2. Pour la première cellule (Index 1), un style de cellule personnalisé est créé à l’aide de \ wb.createCellStyle () \. Ce style est configuré avec une couleur d’arrière-plan aqua en utilisant \ setFillbackgroundColor \ et \ indededColors.aqua.getIndex () \. Le motif de l’arrière-plan est défini sur «Big Spots» à l’aide de \ setFillPattern (FillPatterntype.big_spots) \. Une cellule est créée dans cette ligne à l’index 1 et remplie de la valeur «x». Le style créé précédemment est appliqué à cette cellule en utilisant \ setCellStyle \.
  3. Pour la deuxième cellule (Index 2), un nouveau style de cellule est créé. Ce style est conçu avec une couleur de premier plan orange à l’aide de \ setFillforegroundColor \ et \ indededColors.orange.getIndex () \. Le motif de remplissage est défini sur «Formide solide» à l’aide de \ setFillPattern (FillPatterNTYPE.SOLID_FORDground) \. Une autre cellule est créée à l’index 2 dans la même ligne et peuplée de la valeur «x». Le style nouvellement généré est ensuite attribué à cette cellule en utilisant \ setCellStyle \. Après avoir configuré les apparences de cellules, le classeur modifié est écrit dans un fichier nommé «Workbook.xlsx» à l’aide d’un \ fileoutputStream \. En résumé, cet exemple de code présente comment utiliser la bibliothèque Apache POI pour manipuler les apparences cellulaires dans un fichier Excel. Les techniques démontrées impliquent la création de styles de cellules personnalisés pour contrôler les couleurs d’arrière-plan et de premier plan, ainsi que des modèles de remplissage, offrant une flexibilité dans la personnalisation visuelle des feuilles de calcul Excel à l’aide de Java.

Conclusion

Dans tous les exemples Java ci-dessus pour la bibliothèque Apache POI, nous avons démontré comment travailler avec le contenu des fichiers Excel à partir de votre application Java. Les échantillons de code ont montré comment créer des cellules dans un fichier Excel, définir l’apparence de ceux-ci, définir le style de cellule sur différents types de données tels que la chaîne, le numérique, la décimale, etc., et comment définir le type de cellule sur le type à ce jour. Nous ajouterons plus d’exemples pour travailler avec des fichiers Excel à l’aide d’Apache POI pour Java, alors restez à l’écoute.

Voir aussi