Travailler avec Microsoft Excel en Java

1. introduction

Dans ce tutoriel, nous allons démontrer l'utilisation desApache POI and JExcel APIs for working with Excel spreadsheets.

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

2. Dépendances Maven

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


    org.apache.poi
    poi
    3.15


    org.apache.poi
    poi-ooxml
    3.15

Les dernières versions depoi-ooxml etjxls-jexcel peuvent être téléchargées depuis Maven Central.

3. Apache POI

LeApache POI library supports both .xls and .xlsx files et est une bibliothèque plus complexe que les autres bibliothèques Java pour travailler avec des fichiers Excel.

Il fournit l'interfaceWorkbook pour modéliser un fichierExcel, et les interfacesSheet,Row etCell qui modélisent les éléments d'un fichier Excel, comme ainsi que les implémentations de chaque interface pour les deux formats de fichiers.

Lorsque vous travaillez avec le nouveau format de fichier.xlsx, vous utiliserez les classesXSSFWorkbook, XSSFSheet, XSSFRow, and XSSFCell.

Pour travailler avec l'ancien format.xls, utilisez les classesHSSFWorkbook, HSSFSheet, HSSFRow, etHSSFCell.

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éthodegetCellTypeEnum() de l'interfaceCell.

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 has different methods for reading each type of data. Explorons le contenu de chaque cas de commutateur ci-dessus.

Lorsque la valeur d'énumération du type de cellule estSTRING, le contenu sera lu à l'aide de la méthodegetRichStringCellValue() de l'interfaceCell:

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

Les cellules ayant le type de contenuNUMERIC 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 valeursBOOLEAN, nous avons la méthodegetBooleanCellValue():

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

Et lorsque le type de cellule estFORMULA, nous pouvons utiliser la méthodegetCellFormula():

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 supporte mieux le style que JExcel.

Créons une méthode qui écrit une liste de personnes sur une feuille intitulée“Persons”. Tout d'abord, nous allons créer et styliser une ligne d'en-tête contenant les cellules“Name” et“Age”:

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 testJUnit qui écrit le contenu dans le fichiertemp.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 qui présente l’avantage d’être plus facile à utiliser que 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. The Workbook class represents the entire collection of sheets. La classeSheet représente une seule feuille et la classeCell 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 unHashMap:

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

The WritableCell class has subclasses corresponding to the different types of content pouvant être écrits:Label,DateTime,Number,Boolean,Blank etFormula.

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 de la cellule.

É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“Name” et“Age”:

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 ne pas oublier 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éthodeswrite() etclose() de la classeWorkbook:

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

5. Conclusion

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

Le code source complet de cet article se trouve dans leGitHub project.

TOC

Travailler avec Microsoft Excel en Java