Utilisation de Microsoft Excel en Java

1. Introduction

Dans ce didacticiel, nous allons démontrer l'utilisation des API Apache POI et JExcel pour travailler avec des feuilles de calcul Excel .

Les deux bibliothèques peuvent être utilisées pour lire, écrire et modifier dynamiquement le contenu d'une feuille de calcul Excel et fournir un moyen efficace d'intégrer Microsoft Excel dans une application Java.

2. Dépendances de Maven

Pour commencer, nous devrons ajouter les dépendances suivantes à notre fichier pom.xml :

 org.apache.poi poi 3.15   org.apache.poi poi-ooxml 3.15 

Les dernières versions de poi-ooxml et jxls-jexcel peuvent être téléchargées depuis Maven Central.

3. POI Apache

La bibliothèque Apache POI prend en charge les fichiers .xls et .xlsx et est une bibliothèque plus complexe que les autres bibliothèques Java pour travailler avec des fichiers Excel.

Il fournit l' interface de classeur pour modéliser un fichier Excel et les interfaces de feuille , de ligne et de cellule qui modélisent les éléments d'un fichier Excel, ainsi que des implémentations de chaque interface pour les deux formats de fichier.

Lorsque vous travaillez avec le plus récent .xlsx format de fichier, vous pouvez utiliser les XSSFWorkbook, XSSFSheet, XSSFRow et XSSFCell cours .

Pour travailler avec le plus .xls le format, utilisez les HSSFWorkbook, HSSFSheet, HSSFRow, et HSSFCell cours .

3.1. Lecture depuis Excel

Créons une méthode qui ouvre un fichier .xlsx , puis lit le contenu de la première feuille du fichier.

La méthode de lecture du contenu de la cellule varie en fonction du type de données dans la cellule. Le type de contenu de cellule peut être déterminé à l'aide de la méthode getCellTypeEnum () de l' interface Cell .

Tout d'abord, ouvrons le fichier à partir d'un emplacement donné:

FileInputStream file = new FileInputStream(new File(fileLocation)); Workbook workbook = new XSSFWorkbook(file);

Ensuite, récupérons la première feuille du fichier et parcourons chaque ligne:

Sheet sheet = workbook.getSheetAt(0); Map
    
      data = new HashMap(); int i = 0; for (Row row : sheet) { data.put(i, new ArrayList()); for (Cell cell : row) { switch (cell.getCellTypeEnum()) { case STRING: ... break; case NUMERIC: ... break; case BOOLEAN: ... break; case FORMULA: ... break; default: data.get(new Integer(i)).add(" "); } } i++; }
    

Apache POI a différentes méthodes pour lire chaque type de données. Développons le contenu de chaque cas de commutateur ci-dessus.

Lorsque la valeur d'énumération de type de cellule est STRING , le contenu sera lu à l'aide de la méthode getRichStringCellValue () de l' interface Cell :

data.get(new Integer(i)).add(cell.getRichStringCellValue().getString());

Les cellules de type de contenu NUMERIC peuvent contenir une date ou un nombre et sont lues de la manière suivante:

if (DateUtil.isCellDateFormatted(cell)) { data.get(i).add(cell.getDateCellValue() + ""); } else { data.get(i).add(cell.getNumericCellValue() + ""); }

Pour les valeurs BOOLEAN , nous avons la méthode getBooleanCellValue () :

data.get(i).add(cell.getBooleanCellValue() + "");

Et lorsque le type de cellule est FORMULA , nous pouvons utiliser la méthode getCellFormula () :

data.get(i).add(cell.getCellFormula() + "");

3.2. Écrire dans Excel

Apache POI utilise les mêmes interfaces que celles présentées dans la section précédente pour l'écriture dans un fichier Excel et prend mieux en charge le style que JExcel.

Créons une méthode qui écrit une liste de personnes sur une feuille intitulée «Personnes» . Tout d'abord, nous allons créer et styliser une ligne d'en-tête contenant les cellules «Nom» et «Âge» :

Workbook workbook = new XSSFWorkbook(); Sheet sheet = workbook.createSheet("Persons"); sheet.setColumnWidth(0, 6000); sheet.setColumnWidth(1, 4000); Row header = sheet.createRow(0); CellStyle headerStyle = workbook.createCellStyle(); headerStyle.setFillForegroundColor(IndexedColors.LIGHT_BLUE.getIndex()); headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND); XSSFFont font = ((XSSFWorkbook) workbook).createFont(); font.setFontName("Arial"); font.setFontHeightInPoints((short) 16); font.setBold(true); headerStyle.setFont(font); Cell headerCell = header.createCell(0); headerCell.setCellValue("Name"); headerCell.setCellStyle(headerStyle); headerCell = header.createCell(1); headerCell.setCellValue("Age"); headerCell.setCellStyle(headerStyle);

Ensuite, écrivons le contenu du tableau avec un style différent:

CellStyle style = workbook.createCellStyle(); style.setWrapText(true); Row row = sheet.createRow(2); Cell cell = row.createCell(0); cell.setCellValue("John Smith"); cell.setCellStyle(style); cell = row.createCell(1); cell.setCellValue(20); cell.setCellStyle(style);

Enfin, écrivons le contenu dans un fichier 'temp.xlsx' dans le répertoire actuel et fermons le classeur:

File currDir = new File("."); String path = currDir.getAbsolutePath(); String fileLocation = path.substring(0, path.length() - 1) + "temp.xlsx"; FileOutputStream outputStream = new FileOutputStream(fileLocation); workbook.write(outputStream); workbook.close();

Testons les méthodes ci-dessus dans un test JUnit qui écrit le contenu dans le fichier temp.xlsx puis lit le même fichier pour vérifier qu'il contient le texte que nous avons écrit:

public class ExcelTest { private ExcelPOIHelper excelPOIHelper; private static String FILE_NAME = "temp.xlsx"; private String fileLocation; @Before public void generateExcelFile() throws IOException { File currDir = new File("."); String path = currDir.getAbsolutePath(); fileLocation = path.substring(0, path.length() - 1) + FILE_NAME; excelPOIHelper = new ExcelPOIHelper(); excelPOIHelper.writeExcel(); } @Test public void whenParsingPOIExcelFile_thenCorrect() throws IOException { Map
    
      data = excelPOIHelper.readExcel(fileLocation); assertEquals("Name", data.get(0).get(0)); assertEquals("Age", data.get(0).get(1)); assertEquals("John Smith", data.get(1).get(0)); assertEquals("20", data.get(1).get(1)); } }
    

4. JExcel

La bibliothèque JExcel est une bibliothèque légère ayant l'avantage d'être plus facile à utiliser qu'Apache POI, mais avec l'inconvénient de ne prendre en charge que le traitement des fichiers Excel au format .xls (1997-2003).

Pour le moment, les fichiers .xlsx ne sont pas pris en charge.

4.1. Lecture depuis Excel

Afin de travailler avec des fichiers Excel, cette bibliothèque fournit une série de classes qui représentent les différentes parties d'un fichier Excel. La classe Workbook représente la collection entière de feuilles. La classe Sheet représente une seule feuille et la classe Cell représente une seule cellule d'une feuille de calcul.

Écrivons une méthode qui crée un classeur à partir d'un fichier Excel spécifié, récupère la première feuille du fichier, puis parcourt son contenu et ajoute chaque ligne dans un HashMap :

public class JExcelHelper { public Map
    
      readJExcel(String fileLocation) throws IOException, BiffException { Map
     
       data = new HashMap(); Workbook workbook = Workbook.getWorkbook(new File(fileLocation)); Sheet sheet = workbook.getSheet(0); int rows = sheet.getRows(); int columns = sheet.getColumns(); for (int i = 0; i < rows; i++) { data.put(i, new ArrayList()); for (int j = 0; j < columns; j++) { data.get(i) .add(sheet.getCell(j, i) .getContents()); } } return data; } }
     
    

4.2. Écrire dans Excel

Pour écrire dans un fichier Excel, la bibliothèque JExcel propose des classes similaires à celles utilisées ci-dessus, qui modélisent un fichier de feuille de calcul: WritableWorkbook , WritableSheet et WritableCell .

La classe WritableCell possède des sous-classes correspondant aux différents types de contenu pouvant être écrits: Label , DateHeure , Number , Boolean , Blank et Formula .

Cette bibliothèque prend également en charge les mises en forme de base, telles que le contrôle de la police, de la couleur et de la largeur des cellules.

Écrivons une méthode qui crée un classeur appelé 'temp.xls' dans le répertoire actuel, puis écrit le même contenu que nous avons écrit dans la section Apache POI.

Commençons par créer le classeur:

File currDir = new File("."); String path = currDir.getAbsolutePath(); String fileLocation = path.substring(0, path.length() - 1) + "temp.xls"; WritableWorkbook workbook = Workbook.createWorkbook(new File(fileLocation));

Ensuite, créons la première feuille et écrivons l'en-tête du fichier Excel, contenant les cellules «Nom» et «Âge» :

WritableSheet sheet = workbook.createSheet("Sheet 1", 0); WritableCellFormat headerFormat = new WritableCellFormat(); WritableFont font = new WritableFont(WritableFont.ARIAL, 16, WritableFont.BOLD); headerFormat.setFont(font); headerFormat.setBackground(Colour.LIGHT_BLUE); headerFormat.setWrap(true); Label headerLabel = new Label(0, 0, "Name", headerFormat); sheet.setColumnView(0, 60); sheet.addCell(headerLabel); headerLabel = new Label(1, 0, "Age", headerFormat); sheet.setColumnView(0, 40); sheet.addCell(headerLabel);

Avec un nouveau style, écrivons le contenu du tableau que nous avons créé:

WritableCellFormat cellFormat = new WritableCellFormat(); cellFormat.setWrap(true); Label cellLabel = new Label(0, 2, "John Smith", cellFormat); sheet.addCell(cellLabel); Number cellNumber = new Number(1, 2, 20, cellFormat); sheet.addCell(cellNumber);

Il est très important de se rappeler d'écrire dans le fichier et de le fermer à la fin afin qu'il puisse être utilisé par d'autres processus, en utilisant les méthodes write () et close () de la classe Workbook :

workbook.write(); workbook.close();

5. Conclusion

Ce didacticiel a illustré comment utiliser l' API Apache POI et l'API JExcel pour lire et écrire un fichier Excel à partir d'un programme Java.

Le code source complet de cet article se trouve dans le projet GitHub.