Apache POI - Guide rapide

Plusieurs fois, une application logicielle est nécessaire pour générer des rapports au format de fichier Microsoft Excel. Parfois, une application est même censée recevoir des fichiers Excel en tant que données d'entrée. Par exemple, une application développée pour le service financier d'une entreprise sera nécessaire pour générer toutes ses sorties dans Excel.

Tout programmeur Java souhaitant produire des fichiers MS Office en tant que sortie doit utiliser une API prédéfinie et en lecture seule pour ce faire.

Qu'est-ce que Apache POI?

Apache POI est une API populaire qui permet aux programmeurs de créer, modifier et afficher des fichiers MS Office à l'aide de programmes Java. Il s'agit d'une bibliothèque open source développée et distribuée par Apache Software Foundation pour concevoir ou modifier des fichiers Microsoft Office à l'aide du programme Java. Il contient des classes et des méthodes pour décoder les données d'entrée utilisateur ou un fichier dans des documents MS Office.

Composants d'Apache POI

Apache POI contient des classes et des méthodes pour travailler sur tous les documents OLE2 Compound de MS Office. La liste des composants de cette API est donnée ci-dessous.

POIFS(Mauvais système de fichiers d'implémentation de l'obfuscation) - Ce composant est le facteur de base de tous les autres éléments POI. Il est utilisé pour lire explicitement différents fichiers.
HSSF (Format de feuille de calcul horrible) - Il est utilisé pour lire et écrire xls format des fichiers MS-Excel.
XSSF (Format de feuille de calcul XML) - Il est utilisé pour xlsx format de fichier de MS-Excel.
HPSF (Horrible Property Set Format) - Il est utilisé pour extraire property sets des fichiers MS-Office.
HWPF (Format de traitement de texte horrible) - Il est utilisé pour lire et écrire doc fichiers d'extension de MS-Word.
XWPF (Format de traitement de texte XML) - Il est utilisé pour lire et écrire docx fichiers d'extension de MS-Word.
HSLF (Format de mise en page des diapositives horrible) - Il est utilisé pour lire, créer et modifier des présentations PowerPoint.
HDGF (Horrible DiaGram Format) - Il contient des classes et des méthodes pour MS-Visio fichiers binaires.
HPBF (Horrible PuBlisher Format) - Il est utilisé pour lire et écrire MS-Publisher des dossiers.

Ce didacticiel vous guide tout au long du processus de travail sur des fichiers Excel à l'aide de Java. Par conséquent, la discussion se limite aux composants HSSF et XSSF.

Note - Les anciennes versions de POI prennent en charge les formats de fichiers binaires tels que doc, xls, ppt, etc. À partir de la version 3.5, POI prend en charge les formats de fichiers OOXML de MS-Office tels que docx, xlsx, pptx, etc.

Comme Apache POI, il existe d'autres bibliothèques fournies par divers fournisseurs pour la génération de fichiers Excel. Ceux-ci inclusAspose cells for Java par Aspose, JXL par les bibliothèques communes, et JExcel par Team Dev.

Ce chapitre vous présente certaines des saveurs de l'API Java Excel et leurs fonctionnalités. Il existe de nombreux fournisseurs qui fournissent des API liées à Java Excel; certains d'entre eux sont examinés dans ce chapitre.

Aspose Cells pour Java

Aspose Cells for Java est une API Java Excel sous licence purement développée et distribuée par le fournisseur Aspose. La dernière version de cette API est la 8.1.2, publiée en juillet 2014. Il s'agit d'une API riche et lourde (combinaison de classes Java simples et de classes AWT) pour la conception du composant Excel capable de lire, d'écrire et de manipuler des feuilles de calcul.

Les utilisations courantes de cette API sont les suivantes -

Rapports Excel, créez des rapports Excel dynamiques
Rendu et impression Excel haute fidélité
Importez et exportez des données à partir de feuilles de calcul Excel
Générer, modifier et convertir des feuilles de calcul

JXL

JXL est un framework tiers conçu pour Selenium qui prend en charge l'automatisation basée sur les données sur les navigateurs Web (mise à jour automatique des données sur les navigateurs Web). Cependant, il est également utilisé comme bibliothèque de support commune pour l'API JExcel car il possède des fonctionnalités de base pour créer, lire et écrire des feuilles de calcul.

Les fonctionnalités de base sont les suivantes -

Générer des fichiers Excel
Importer des données à partir de classeurs et de feuilles de calcul
Obtenez le nombre total de lignes et de colonnes

Note - JXL prend uniquement en charge le format de fichier .xls et ne peut pas gérer un volume de données important.

JExcel

JExcel est une API purement sous licence fournie par Team Dev. Grâce à cela, les programmeurs peuvent facilement lire, écrire, afficher et modifier des classeurs Excel dans les deux.xls et .xlsxformats. Cette API peut être facilement intégrée avec Java Swing et AWT. La dernière version de cette API est Jexcel-2.6.12, publiée en 2009.

Les principales caractéristiques sont les suivantes -

Automatisez l'application Excel, les classeurs, les feuilles de calcul, etc.
Incorporer des classeurs dans une application Java Swing en tant que composant Swing ordinaire
Ajouter des écouteurs d'événements aux classeurs et aux feuilles de calcul
Ajouter des gestionnaires d'événements pour gérer le comportement des événements de classeur et de feuille de calcul
Ajouter des pairs natifs pour développer des fonctionnalités personnalisées

POI Apache

Apache POI est une bibliothèque 100% open source fournie par Apache Software Foundation. La plupart des développeurs d'applications à petite et moyenne échelle dépendent fortement d'Apache POI (HSSF + XSSF). Il prend en charge toutes les fonctionnalités de base des bibliothèques Excel; cependant, le rendu et l'extraction de texte sont ses principales caractéristiques.

Ce chapitre vous guide tout au long du processus de configuration d'Apache POI sur les systèmes Windows et Linux. Apache POI peut être facilement installé et intégré à votre environnement Java actuel en quelques étapes simples sans aucune procédure de configuration complexe. L'administration des utilisateurs est requise lors de l'installation.

Configuration requise

JDK	Java SE 2 JDK 1.5 ou supérieur
Mémoire	1 Go de RAM (recommandé)
Espace disque	Aucune exigence minimale
Version du système d'exploitation	Windows XP ou supérieur, Linux

Passons maintenant aux étapes d'installation d'Apache POI.

Étape 1: Vérifiez votre installation Java

Tout d'abord, vous devez disposer du kit de développement logiciel Java (SDK) installé sur votre système. Pour vérifier cela, exécutez l'une des deux commandes en fonction de la plate-forme sur laquelle vous travaillez.

Si l'installation de Java a été effectuée correctement, la version actuelle et les spécifications de votre installation Java seront affichées. Un exemple de sortie est donné dans le tableau suivant.

Plate-forme	Commander	Exemple de sortie
les fenêtres	Ouvrez la console de commande et tapez - \>java –version	Version Java "1.7.0_60" Environnement d'exécution Java (TM) SE (build 1.7.0_60-b19) VM serveur 64 bits Java Hotspot (TM) (build 24.60-b09, mode mixte)
Linux	Ouvrez le terminal de commande et tapez - $java –version	version java "1.7.0_25" Ouvrir l'environnement d'exécution JDK (rhel-2.3.10.4.el6_4-x86_64) Ouvrez la machine virtuelle serveur JDK 64 bits (build 23.7-b01, mode mixte)

Nous supposons que les lecteurs de ce didacticiel ont installé la version 1.7.0_60 du SDK Java sur leur système.
Si vous ne disposez pas du SDK Java, téléchargez sa version actuelle sur https://www.oracle.com/technetwork/java/javase/downloads/index.html et faites-le installer.

Étape 2: définissez votre environnement Java

Définissez la variable d'environnement JAVA_HOME pour qu'elle pointe vers l'emplacement du répertoire de base où Java est installé sur votre machine. Par exemple,

Sr.No.	Plateforme et description
1	Windows Définissez JAVA_HOME sur C: \ ProgramFiles \ java \ jdk1.7.0_60
2	Linux Exporter JAVA_HOME = / usr / local / java-current

Ajoutez le chemin complet de l'emplacement du compilateur Java au chemin système.

Sr.No.	Plateforme et description
1	Windows Ajoutez la chaîne «C: \ Program Files \ Java \ jdk1.7.0_60 \ bin» à la fin de la variable système PATH.
2	Linux Exporter PATH = $ PATH: $ JAVA_HOME / bin /

Exécutez la commande java -version à partir de l'invite de commande comme expliqué ci-dessus.

Étape 3: Installez la bibliothèque de POI Apache

Téléchargez la dernière version d'Apache POI sur https://poi.apache.org/download.htmlet décompressez son contenu dans un dossier à partir duquel les bibliothèques requises peuvent être liées à votre programme Java. Supposons que les fichiers sont collectés dans un dossier sur le lecteur C.

Les images suivantes montrent les répertoires et la structure des fichiers dans le dossier téléchargé.

Ajoutez le chemin complet des cinq jars comme mis en évidence dans l'image ci-dessus au CLASSPATH.

Sr.No.	Plateforme et description
1	Windows Ajoutez les chaînes suivantes à la fin de la variable utilisateur CLASSPATH - «C: \ poi-3.9 \ poi-3.9-20121203.jar;» «C: \ poi-3.9 \ poi-ooxml-3.9-20121203.jar;» «C: \ poi-3.9 \ poi-ooxml-schemas-3.9-20121203.jar;» «C: \ poi-3.9 \ ooxml-lib \ dom4j-1.6.1.jar;» «C: \ poi-3.9 \ ooxml-lib \ xmlbeans-2.3.0.jar;.;»
2	Linux Exporter CLASSPATH = $ CLASSPATH: /usr/share/poi-3.9/poi-3.9-20121203.tar: /usr/share/poi-3.9/poi-ooxml-schemas-3.9-20121203.tar: /usr/share/poi-3.9/poi-ooxml-3.9-20121203.tar: /usr/share/poi-3.9/ooxml-lib/dom4j-1.6.1.tar: /usr/share/poi-3.9/ooxml-lib/xmlbeans-2.3.0.tar

Ce chapitre explique quelques classes et méthodes de l'API Apache POI qui sont essentielles pour travailler sur des fichiers Excel à l'aide de programmes Java.

Classeur

Il s'agit de la super-interface de toutes les classes qui créent ou gèrent des classeurs Excel. Il appartient à laorg.apache.poi.ss.usermodelpaquet. Les deux classes qui implémentent cette interface sont les suivantes -

HSSFWorkbook- Cette classe a des méthodes pour lire et écrire des fichiers Microsoft Excel au format .xls. Il est compatible avec les versions 97–2003 de MS-Office.
XSSFWorkbook- Cette classe a des méthodes pour lire et écrire des fichiers Microsoft Excel et OpenOffice xml au format .xls ou .xlsx. Il est compatible avec les versions 2007 ou ultérieures de MS-Office.

HSSFWorkbook

C'est une classe de haut niveau sous le org.apache.poi.hssf.usermodelpaquet. Il met en œuvre leWorkbookinterface et est utilisé pour les fichiers Excel au format .xls. Vous trouverez ci-dessous quelques-unes des méthodes et des constructeurs de cette classe.

Constructeurs de classe

Sr.No.	Constructeur et description
1	HSSFWorkbook() Crée un nouvel objet HSSFWorkbook à partir de zéro.
2	HSSFWorkbook(DirectoryNode directory, boolean preserveNodes) Crée un nouvel objet HSSFWworkbook dans un répertoire spécifique.
3	HSSFWorkbook(DirectoryNode directory, POIFSFileSystem fs, boolean preserveNodes) Étant donné un objet POIFSFileSystem et un répertoire spécifique qu'il contient, il crée un objet SSFWorkbook pour lire un classeur spécifié.
4	HSSFWorkbook(java.io.InputStream s) Crée un nouvel objet HSSFWorkbook à l'aide d'un flux d'entrée.
5	HSSFWorkbook(java.io.InputStream s, boolean preserveNodes) Construit un système de fichiers POI autour de votre flux d'entrée.
6	HSSFWorkbook(POIFSFileSystem fs) Construit un nouvel objet HSSFWorkbook à l'aide d'un objet POIFSFileSystem.
sept	HSSFWorkbook(POIFSFileSystem fs, boolean preserveNodes) Étant donné un objet POIFSFileSystem, il crée un nouvel objet HSSFWorkbook pour lire un classeur spécifié.

Les paramètres fréquemment utilisés à l'intérieur de ces constructeurs sont -

directory - Il s'agit du répertoire du système de fichiers POI à partir duquel traiter.
fs - C'est le système de fichiers POI qui contient le flux de classeur.
preservenodes- C'est un paramètre facultatif qui décide s'il faut conserver d'autres nœuds comme des macros. Il consomme beaucoup de mémoire car il stocke tout POIFileSystem en mémoire (s'il est défini).

Note- La classe HSSFWorkbook contient un certain nombre de méthodes; cependant, ils ne sont compatibles qu'avec le format xls. Dans ce didacticiel, l'accent est mis sur la dernière version des formats de fichiers Excel. Par conséquent, les méthodes de classe de HSSFWorkbook ne sont pas répertoriées ici. Si vous avez besoin de ces méthodes de classe, reportez-vous à l'API de classe POI-HSSFWorkbook à l'adressehttps://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFWorkbook.html.

XSSFWorkbook

Il s'agit d'une classe utilisée pour représenter les formats de fichiers Excel de haut et de bas niveau. Il appartient à laorg.apache.xssf.usemodel package et implémente le Workbookinterface. Vous trouverez ci-dessous les méthodes et les constructeurs de cette classe.

Constructeurs de classe

Sr.No.	Constructeur et description
1	XSSFWorkbook() Crée un nouvel objet XSSFworkbook à partir de zéro.
2	XSSFWorkbook(java.io.File file) Construit un objet XSSFWorkbook à partir d'un fichier donné.
3	XSSFWorkbook(java.io.InputStream is) Construit un objet XSSFWorkbook, en mettant en mémoire tampon tout le flux d'entrée en mémoire, puis en ouvrant un objet OPCPackage pour celui-ci.
4	XSSFWorkbook(java.lang.String path) Construit un objet XSSFWorkbook en fonction du chemin complet d'un fichier.

Méthodes de classe

Sr.No.	Méthode et description
1	createSheet() Crée une feuille XSSFS pour ce classeur, l'ajoute aux feuilles et renvoie la représentation de haut niveau.
2	createSheet(java.lang.String sheetname) Crée une nouvelle feuille pour ce classeur et renvoie la représentation de haut niveau.
3	createFont() Crée une nouvelle police et l'ajoute à la table de polices du classeur.
4	createCellStyle() Crée un nouveau XSSFCellStyle et l'ajoute à la table de styles du classeur.
5	createFont() Crée une nouvelle police et l'ajoute à la table de polices du classeur.
6	setPrintArea(int sheetIndex, int startColumn, int endColumn, int startRow,int endRow) Définit la zone d'impression d'une feuille donnée selon les paramètres spécifiés.

Pour les autres méthodes de cette classe, reportez-vous au document API complet à l'adresse: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFWorkbook.html. pour la liste complète des méthodes.

Feuille

La feuille est une interface sous le org.apache.poi.ss.usermodelpackage et c'est une super-interface de toutes les classes qui créent des feuilles de calcul de haut ou bas niveau avec des noms spécifiques. Le type de feuille de calcul le plus courant est la feuille de calcul, qui est représentée sous la forme d'une grille de cellules.

Feuille HSSF

Ceci est une classe sous le org.apache.poi.hssf.usermodelpaquet. Il peut créer des feuilles de calcul Excel et il permet de formater le style de feuille et les données de la feuille.

Constructeurs de classe

Sr.No.	Constructeur et description
1	HSSFSheet(HSSFWorkbook workbook) Crée une nouvelle feuille HSSFS appelée par HSSFWorkbook pour créer une feuille à partir de zéro.
2	HSSFSheet(HSSFWorkbook workbook, InternalSheet sheet) Crée une feuille HSSFS représentant l'objet feuille donné.

XSSFSheet

Il s'agit d'une classe qui représente une représentation de haut niveau de la feuille de calcul Excel. C'est sousorg.apache.poi.hssf.usermodel paquet.

Constructeurs de classe

Sr.No.	Constructeur et description
1	XSSFSheet() Crée une nouvelle feuille XSSFS - appelée par XSSFWorkbook pour créer une feuille à partir de zéro.
2	XSSFSheet(PackagePart part, PackageRelationship rel) Crée une feuille XSSFS représentant la partie et la relation de package données.

Méthodes de classe

Sr.No.	Méthode et description
1	addMergedRegion(CellRangeAddress region) Ajoute une région fusionnée de cellules (par conséquent, ces cellules n'en forment qu'une).
2	autoSizeColumn(int column) Ajuste la largeur de la colonne en fonction du contenu.
3	iterator() Cette méthode est un alias pour rowIterator () pour autoriser les boucles foreach
4	addHyperlink(XSSFHyperlink hyperlink) Enregistre un hyperlien dans la collection d'hyperliens de cette feuille

Pour les autres méthodes de cette classe, reportez-vous à l'API complète à l'adresse: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFSheet.html.

Rangée

Ceci est une interface sous le org.apache.poi.ss.usermodelpaquet. Il est utilisé pour la représentation de haut niveau d'une ligne d'une feuille de calcul. C'est une super-interface de toutes les classes qui représentent des lignes dans la bibliothèque POI.

XSSFRow

Ceci est une classe sous le org.apache.poi.xssf.usermodelpaquet. Il implémente l'interface Row, donc il peut créer des lignes dans une feuille de calcul. Vous trouverez ci-dessous les méthodes et les constructeurs de cette classe.

Méthodes de classe

Sr.No.	Méthode et description
1	createCell(int columnIndex) Crée de nouvelles cellules dans la ligne et la renvoie.
2	setHeight(short height) Définit la hauteur en unités courtes.

Pour les autres méthodes de cette classe, suivez le lien donné https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFRow.html

Cellule

Ceci est une interface sous le org.apache.poi.ss.usermodelpaquet. C'est une super-interface de toutes les classes qui représentent des cellules dans les lignes d'une feuille de calcul.

Les cellules peuvent prendre divers attributs tels que vide, numérique, date, erreur, etc. Les cellules doivent avoir leurs propres nombres (basés sur 0) avant d'être ajoutées à une ligne.

XSSFCell

Ceci est une classe sous le org.apache.poi.xssf.usermodelpaquet. Il implémente l'interface Cell. Il s'agit d'une représentation de haut niveau des cellules dans les lignes d'une feuille de calcul.

Résumé du champ

Vous trouverez ci-dessous certains des champs de la classe XSSFCell avec leur description.

Sr.No.	Type de cellule et description
1	CELL_TYPE_BLANK Représente une cellule vide
2	CELL_TYPE_BOOLEAN Représente la cellule booléenne (vrai ou faux)
3	CELL_TYPE_ERROR Représente la valeur d'erreur sur une cellule
4	CELL_TYPE_FORMULA Représente le résultat de la formule sur une cellule
5	CELL_TYPE_NUMERIC Représente des données numériques sur une cellule
6	CELL_TYPE_STRING Représente une chaîne (texte) sur une cellule

Méthodes de classe

Sr.No.	Méthode et description
1	setCellStyle(CellStyle style) Définit le style de la cellule.
2	setCellType(int cellType) Définit le type de cellules (numérique, formule ou chaîne).
3	setCellValue(boolean value) Définit une valeur booléenne pour la cellule.
4	setCellValue(java.util.Calendar value) Définit une valeur de date pour la cellule.
5	setCellValue(double value) Définit une valeur numérique pour la cellule.
6	setCellValue(java.lang.String str) Définit une valeur de chaîne pour la cellule.
sept	setHyperlink(Hyperlink hyperlink) Attribue un lien hypertexte à cette cellule.

Pour les méthodes et champs restants de cette classe, visitez le lien suivant: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCell.html

XSSFCellStyle

Ceci est une classe sous le org.apache.poi.xssf.usermodelpaquet. Il fournira des informations éventuelles concernant le format du contenu dans une cellule d'une feuille de calcul. Il fournit également des options pour modifier ce format. Il implémente l'interface CellStyle.

Résumé du champ

Le tableau suivant répertorie quelques champs hérités de l'interface CellStyle.

Sr.No.	Champ et description
1	ALIGN_CENTER Centrer aligner le contenu de la cellule
2	ALIGN_CENTER_SELECTION Alignement horizontal de sélection centrale
3	ALIGN_FILL La cellule s'adapte à la taille du contenu
4	ALIGN_JUSTIFY Ajuster le contenu de la cellule à sa largeur
5	ALIGN_LEFT Aligner à gauche le contenu de la cellule
6	ALIGN_RIGHT Alignez à droite le contenu de la cellule
sept	BORDER_DASH_DOT Style de cellule avec tiret et point
8	BORDER_DOTTED Style de cellule avec bordure en pointillé
9	BORDER_DASHED Style de cellule avec bordure en pointillés
dix	BORDER_THICK Style de cellule avec bordure épaisse
11	BORDER_THIN Style de cellule avec bordure fine
12	VERTICAL_BOTTOM Aligner le contenu de la cellule verticalement en bas
13	VERTICAL_CENTER Aligner le centre vertical du contenu de la cellule
15	VERTICAL_JUSTIFY Aligner et justifier le contenu de la cellule verticalement
16	VERTICAL_TOP Alignement vertical aligné en haut

Constructeurs de classe

Sr.No.	Constructeur et description
1	XSSFCellStyle(int cellXfId, int cellStyleXfId, StylesTable stylesSource, ThemesTable theme) Crée un style de cellule à partir des pièces fournies
2	XSSFCellStyle(StylesTable stylesSource) Crée un style de cellule vide

Méthodes de classe

S. Non	Méthode et description
1	setAlignment(short align) Définit le type d'alignement horizontal de la cellule
2	setBorderBottom(short border) Définit le type de bordure pour la bordure inférieure de la cellule
3	setBorderColor(XSSFCellBorder.BorderSide side, XSSFColor color) Définit la couleur de la bordure sélectionnée
4	setBorderLeft(Short border) Définit le type de bordure pour la bordure gauche de la cellule
5	setBorderRight(short border) Définit le type de bordure pour la bordure droite de la cellule
6	setBorderTop(short border) Définit le type de bordure pour la bordure supérieure de la cellule
sept	setFillBackgroundColor(XSSFColor color) Définit la couleur de remplissage d'arrière-plan représentée comme une valeur XSSFColor.
8	setFillForegroundColor(XSSFColor color) Définit la couleur de remplissage de premier plan représentée comme une valeur XSSFColor.
9	setFillPattern(short fp) Spécifie les informations de remplissage de cellule pour les motifs et les remplissages de cellule de couleur unie.
dix	setFont(Font font) Définit la police de ce style.
11	setRotation(short rotation) Définit le degré de rotation du texte dans la cellule.
12	setVerticalAlignment(short align) Définit le type d'alignement vertical de la cellule.

Pour les méthodes et champs restants de cette classe, passez par le lien suivant: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCellStyle.html

HSSFCouleur

Ceci est une classe sous le org.apache.poi.hssf.utilpaquet. Il fournit différentes couleurs sous forme de classes imbriquées. Habituellement, ces classes imbriquées sont représentées à l'aide de leurs propres index. Il implémente l'interface Color.

Classes imbriquées

Toutes les classes imbriquées de cette classe sont statiques et chaque classe a son index. Ces classes de couleurs imbriquées sont utilisées pour la mise en forme des cellules telles que le contenu de la cellule, la bordure, le premier plan et l'arrière-plan. Voici quelques-unes des classes imbriquées.

Sr.No.	Noms de classe (couleurs)
1	HSSFColor.AQUA
2	HSSFColor.AUTOMATIQUE
3	HSSFCouleur.BLACK
4	HSSFColor.BLUE
5	HSSFColor.BRIGHT_GREEN
6	HSSFColor.BRIGHT_GRAY
sept	HSSFCouleur.CORAL
8	HSSFColor.DARK_BLUE
9	HSSFColor.DARK_GREEN
dix	HSSFColor.SKY_BLUE
11	HSSFColor.WHITE
12	HSSFCouleur.JAUNE

Méthodes de classe

Une seule méthode de cette classe est importante et qui est utilisée pour obtenir la valeur d'index.

Sr.No.	Méthode et description
1	getIndex() Cette méthode est utilisée pour obtenir la valeur d'index d'une classe imbriquée.

Pour les méthodes restantes et les classes imbriquées, reportez-vous au lien suivant: https://poi.apache.org/apidocs/org/apache/poi/hssf/util/HSSFColor.html

XSSFCouleur

Ceci est une classe sous le org.apache.poi.xssf.usermodelpaquet. Il est utilisé pour représenter la couleur dans une feuille de calcul. Il implémente l'interface Color. Vous trouverez ci-dessous quelques-unes de ses méthodes et constructeurs.

Constructeurs de classe

Sr.No.	Constructeur et description
1	XSSFColor() Crée une nouvelle instance de XSSFColor.
2	XSSFColor(byte[] rgb) Crée une nouvelle instance de XSSFColor à l'aide de RVB.
3	XSSFColor(java.awt.Color clr) Crée une nouvelle instance de XSSFColor à l'aide de la classe Color du package awt.

Méthodes de classe

Sr.No.	Méthode et description
1	setAuto(boolean auto) Définit une valeur booléenne pour indiquer que ctColor est automatique et que le système ctColor est dépendant.
2	setIndexed(int indexed) Définit la valeur ctColor indexée comme système ctColor.

Pour les autres méthodes, visitez le lien suivant: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFColor.html

XSSFFont

Ceci est une classe sous le org.apache.poi.xssf.usermodelpaquet. Il implémente l'interface de police et peut donc gérer différentes polices dans un classeur.

Constructeur de classe

Sr.No.	Constructeur et description
1	XSSFFont() Crée une nouvelle instance XSSFont.

Méthodes de classe

Sr.No.	Méthode et description
1	setBold(boolean bold) Définit une valeur booléenne pour l'attribut 'bold'.
2	setColor(short color) Définit la couleur indexée de la police.
3	setColor(XSSFColor color) Définit la couleur de la police dans la valeur de couleur RVB Alpha standard.
4	setFontHeight(short height) Définit la hauteur de la police en points.
5	setFontName(java.lang.String name) Définit le nom de la police.
6	setItalic(boolean italic) Définit une valeur booléenne pour la propriété 'italic'.

Pour les méthodes restantes, passez par le lien suivant: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFFont.html

XSSFHyperlink

Ceci est une classe sous le org.apache.poi.xssf.usermodelpaquet. Il implémente l'interface Hyperlink. Il est utilisé pour définir un lien hypertexte vers le contenu des cellules d'une feuille de calcul.

Des champs

Les champs de cette classe sont les suivants. Ici, les champs désignent les types d'hyperliens utilisés.

Sr.No.	Champ et description
1	LINK_DOCUMENT Utilisé pour lier tout autre document
2	LINK_EMAIL Utilisé pour lier un e-mail
3	LINK_FILE Utilisé pour lier tout autre fichier dans n'importe quel format
4	LINK_URL Utilisé pour lier une URL Web

Méthodes de classe

Sr.No.	Méthode et description
1	setAddress(java.lang.String address) Adresse du lien hypertexte.

Pour les autres méthodes, visitez le lien suivant: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFHyperlink.html

XSSFCreationHelper

Ceci est une classe sous le org.apache.poi.xssf.usermodelpaquet. Il implémente l'interface CreationHelper. Il est utilisé comme classe de support pour l'évaluation des formules et la configuration des hyperliens.

Méthodes de classe

Sr.No.	Méthode et description
1	createFormulaEvaluator() Crée une instance XSSFFormulaEvaluator, l'objet qui évalue les cellules de formule.
2	createHyperlink(int type) Crée un nouveau XSSFHyperlink.

Pour les autres méthodes, reportez-vous au lien suivant: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCreationHelper.html

XSSFPrintSetup

Ceci est une classe sous le org.apache.poi.xsssf.usermodelpaquet. Il met en œuvre lePrintSetupinterface. Il est utilisé pour définir la taille, la zone, les options et les paramètres de la page d'impression.

Méthodes de classe

Sr.No.	Méthode et description
1	setLandscape(boolean ls) Définit une valeur booléenne pour autoriser ou bloquer l'impression paysage.
2	setLeftToRight(boolean ltor) Définit s'il faut aller de gauche à droite ou de haut en bas dans l'ordre lors de l'impression.
3	setPaperSize(short size) Définit le format du papier.

Pour les autres méthodes, visitez le lien suivant: https://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFPrintSetup.html

Ici, le terme «classeur» désigne un fichier Microsoft Excel. Une fois ce chapitre terminé, vous pourrez créer de nouveaux classeurs et ouvrir des classeurs existants avec votre programme Java.

Créer un classeur vierge

Le programme simple suivant est utilisé pour créer un classeur Microsoft Excel vierge.

import java.io.*;
import org.apache.poi.xssf.usermodel.*;

public class CreateWorkBook {
   public static void main(String[] args)throws Exception {
      //Create Blank workbook
      XSSFWorkbook workbook = new XSSFWorkbook(); 

      //Create file system using specific name
      FileOutputStream out = new FileOutputStream(new File("createworkbook.xlsx"));

      //write operation workbook using file out object 
      workbook.write(out);
      out.close();
      System.out.println("createworkbook.xlsx written successfully");
   }
}

Sauvegardons le code Java ci-dessus sous CreateWorkBook.java, puis compilez et exécutez-le à partir de l'invite de commande comme suit -

$javac CreateWorkBook.java $java CreateWorkBook

Si votre environnement système est configuré avec la bibliothèque POI, il sera compilé et exécuté pour générer le fichier Excel vierge nommé createworkbook.xlsx dans votre répertoire actuel et affichez la sortie suivante dans l'invite de commande.

createworkbook.xlsx written successfully

Ouvrir le classeur existant

Utilisez le code suivant pour ouvrir un classeur existant.

import java.io.*;
import org.apache.poi.xssf.usermodel.*;

public class OpenWorkBook {
   public static void main(String args[])throws Exception { 
      File file = new File("openworkbook.xlsx");
      FileInputStream fIP = new FileInputStream(file);
      
      //Get the workbook instance for XLSX file 
      XSSFWorkbook workbook = new XSSFWorkbook(fIP);
      
      if(file.isFile() && file.exists()) {
         System.out.println("openworkbook.xlsx file open successfully.");
      } else {
         System.out.println("Error to open openworkbook.xlsx file.");
      }
   }
}

Enregistrez le code Java ci-dessus sous OpenWorkBook.java, puis compilez et exécutez-le à partir de l'invite de commande comme suit -

$javac OpenWorkBook.java $java OpenWorkBook

Il se compilera et s'exécutera pour générer la sortie suivante.

openworkbook.xlsx file open successfully.

Après avoir ouvert un classeur, vous pouvez y effectuer des opérations de lecture et d'écriture.

Ce chapitre explique comment créer une feuille de calcul et la manipuler à l'aide de Java. La feuille de calcul est une page dans un fichier Excel; il contient des lignes et des colonnes avec des noms spécifiques.

Après avoir terminé ce chapitre, vous pourrez créer une feuille de calcul et y effectuer des opérations de lecture.

Créer une feuille de calcul

Tout d'abord, créons une feuille de calcul en utilisant les classes référencées discutées dans les chapitres précédents. En suivant le chapitre précédent, créez d'abord un classeur, puis nous pouvons continuer et créer une feuille.

L'extrait de code suivant est utilisé pour créer une feuille de calcul.

//Create Blank workbook
XSSFWorkbook workbook = new XSSFWorkbook();

//Create a blank spreadsheet
XSSFSheet spreadsheet = workbook.createSheet("Sheet Name");

Lignes sur la feuille de calcul

Les feuilles de calcul ont une disposition en grille. Les lignes et les colonnes sont identifiées par des noms spécifiques. Les colonnes sont identifiées par des alphabets et les lignes par des nombres.

L'extrait de code suivant est utilisé pour créer une ligne.

XSSFRow row = spreadsheet.createRow((short)1);

Écrire dans une feuille de calcul

Prenons un exemple de données sur les employés. Ici, les données des employés sont présentées sous forme de tableau.

ID Emp	Nom de l'emp	La désignation
Tp01	Gopal	Directeur technique
TP02	Manisha	Lecteur d'épreuves
Tp03	Masthan	Rédacteur technique
Tp04	Satish	Rédacteur technique
Tp05	Krishna	Rédacteur technique

Le code suivant est utilisé pour écrire les données ci-dessus dans une feuille de calcul.

import java.io.File;
import java.io.FileOutputStream;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Writesheet {
   public static void main(String[] args) throws Exception {

      //Create blank workbook
      XSSFWorkbook workbook = new XSSFWorkbook(); 

      //Create a blank sheet
      XSSFSheet spreadsheet = workbook.createSheet(" Employee Info ");

      //Create row object
      XSSFRow row;

      //This data needs to be written (Object[])
      Map < String, Object[] > empinfo = 
      new TreeMap < String, Object[] >();
      empinfo.put( "1", new Object[] { "EMP ID", "EMP NAME", "DESIGNATION" });
      empinfo.put( "2", new Object[] { "tp01", "Gopal", "Technical Manager" });
      empinfo.put( "3", new Object[] { "tp02", "Manisha", "Proof Reader" });
      empinfo.put( "4", new Object[] { "tp03", "Masthan", "Technical Writer" });
      empinfo.put( "5", new Object[] { "tp04", "Satish", "Technical Writer" });
      empinfo.put( "6", new Object[] { "tp05", "Krishna", "Technical Writer" });
      
      //Iterate over data and write to sheet
      Set < String > keyid = empinfo.keySet();
      int rowid = 0;

      for (String key : keyid) {
         row = spreadsheet.createRow(rowid++);
         Object [] objectArr = empinfo.get(key);
         int cellid = 0;

         for (Object obj : objectArr) {
            Cell cell = row.createCell(cellid++);
            cell.setCellValue((String)obj);
         }
      }

      //Write the workbook in file system
      FileOutputStream out = new FileOutputStream(new File("Writesheet.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("Writesheet.xlsx written successfully");
   }
}

Enregistrez le code Java ci-dessus sous Writesheet.java, puis compilez et exécutez-le à partir de l'invite de commande comme suit -

$javac Writesheet.java $java Writesheet

Il se compilera et s'exécutera pour générer un fichier Excel nommé Writesheet.xlsx dans votre répertoire actuel et vous obtiendrez la sortie suivante dans l'invite de commande.

Writesheet.xlsx written successfully

le Writesheet.xlsx Le fichier ressemble à ce qui suit.

Lire à partir d'une feuille de calcul

Considérons le fichier Excel ci-dessus nommé Writesheet.xslxcomme entrée. Observez le code suivant; il est utilisé pour lire les données d'une feuille de calcul.

import java.io.File;
import java.io.FileInputStream;

import java.util.Iterator;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Readsheet {
   static XSSFRow row;
   public static void main(String[] args) throws Exception {
      FileInputStream fis = new FileInputStream(new File("WriteSheet.xlsx"));
      
      XSSFWorkbook workbook = new XSSFWorkbook(fis);
      XSSFSheet spreadsheet = workbook.getSheetAt(0);
      Iterator < Row >  rowIterator = spreadsheet.iterator();
      
      while (rowIterator.hasNext()) {
         row = (XSSFRow) rowIterator.next();
         Iterator < Cell >  cellIterator = row.cellIterator();
         
         while ( cellIterator.hasNext()) {
            Cell cell = cellIterator.next();
            
            switch (cell.getCellType()) {
               case Cell.CELL_TYPE_NUMERIC:
                  System.out.print(cell.getNumericCellValue() + " \t\t ");
                  break;
               
               case Cell.CELL_TYPE_STRING:
                  System.out.print(
                  cell.getStringCellValue() + " \t\t ");
                  break;
            }
         }
         System.out.println();
      }
      fis.close();
   }
}

Gardons le code ci-dessus dans Readsheet.java fichier, puis compilez et exécutez-le à partir de l'invite de commande comme suit -

$javac Readsheet.java $java Readsheet

Si votre environnement système est configuré avec la bibliothèque POI, il sera compilé et exécuté pour générer la sortie suivante dans l'invite de commande.

EMP ID   EMP NAME       DESIGNATION 
 tp01     Gopal       Technical Manager 
 tp02     Manisha     Proof Reader 
 tp03     Masthan     Technical Writer 
 tp04     Satish      Technical Writer 
 tp05     Krishna     Technical Writer

Toutes les données que vous entrez dans une feuille de calcul sont toujours stockées dans une cellule. Nous utilisons les étiquettes des lignes et des colonnes pour identifier une cellule. Ce chapitre décrit comment manipuler les données dans les cellules d'une feuille de calcul à l'aide de la programmation Java.

Créer une cellule

Vous devez créer une ligne avant de créer une cellule. Une ligne n'est rien d'autre qu'une collection de cellules.

L'extrait de code suivant est utilisé pour créer une cellule.

//create new workbook
XSSFWorkbook workbook = new XSSFWorkbook(); 

//create spreadsheet with a name
XSSFSheet spreadsheet = workbook.createSheet("new sheet");

//create first row on a created spreadsheet
XSSFRow row = spreadsheet.createRow(0);

//create first cell on created row
XSSFCell cell = row.createCell(0);

Types de cellules

Le type de cellule spécifie si une cellule peut contenir des chaînes, une valeur numérique ou des formules. Une cellule de chaîne ne peut pas contenir de valeurs numériques et une cellule numérique ne peut pas contenir de chaînes. Vous trouverez ci-dessous les types de cellules, leurs valeurs et la syntaxe des types.

Type de valeur de cellule	Syntaxe de type
Valeur de cellule vide	XSSFCell.CELL_TYPE_BLANK
Valeur de cellule booléenne	XSSFCell.CELL.TYPE_BOOLEAN
Valeur de la cellule d'erreur	XSSFCell.CELL_TYPE_ERROR
Valeur de cellule numérique	XSSFCell.CELL_TYPE_NUMERIC
Valeur de la cellule de chaîne	XSSFCell.CELL_TYPE_STRING

Le code suivant est utilisé pour créer différents types de cellules dans une feuille de calcul.

import java.io.File;
import java.io.FileOutputStream;

import java.util.Date;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class TypesofCells {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("cell types");
      
      XSSFRow row = spreadsheet.createRow((short) 2);
      row.createCell(0).setCellValue("Type of Cell");
      row.createCell(1).setCellValue("cell value");
      
      row = spreadsheet.createRow((short) 3);
      row.createCell(0).setCellValue("set cell type BLANK");
      row.createCell(1);
      
      row = spreadsheet.createRow((short) 4);
      row.createCell(0).setCellValue("set cell type BOOLEAN");
      row.createCell(1).setCellValue(true);
      
      row = spreadsheet.createRow((short) 5);
      row.createCell(0).setCellValue("set cell type ERROR");
      row.createCell(1).setCellValue(XSSFCell.CELL_TYPE_ERROR );
      
      row = spreadsheet.createRow((short) 6);
      row.createCell(0).setCellValue("set cell type date");
      row.createCell(1).setCellValue(new Date());
      
      row = spreadsheet.createRow((short) 7);
      row.createCell(0).setCellValue("set cell type numeric");
      row.createCell(1).setCellValue(20 );
      
      row = spreadsheet.createRow((short) 8);
      row.createCell(0).setCellValue("set cell type string");
      row.createCell(1).setCellValue("A String");
      
      FileOutputStream out = new FileOutputStream(new File("typesofcells.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("typesofcells.xlsx written successfully");
   }
}

Enregistrez le code ci-dessus dans un fichier nommé TypesofCells.java, compilez-le et exécutez-le à partir de l'invite de commande comme suit.

$javac TypesofCells.java $java TypesofCells

Si votre système est configuré avec la bibliothèque POI, il se compilera et s'exécutera pour générer un fichier Excel nommé typesofcells.xlsx dans votre répertoire actuel et affichez la sortie suivante.

typesofcells.xlsx written successfully

le typesofcells.xlsx Le fichier ressemble à ce qui suit.

Styles de cellule

Ici, vous pouvez apprendre à mettre en forme les cellules et à appliquer différents styles tels que la fusion de cellules adjacentes, l'ajout de bordures, la définition de l'alignement des cellules et le remplissage avec des couleurs.

Le code suivant est utilisé pour appliquer différents styles aux cellules à l'aide de la programmation Java.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class CellStyle {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("cellstyle");
      XSSFRow row = spreadsheet.createRow((short) 1);
      row.setHeight((short) 800);
      XSSFCell cell = (XSSFCell) row.createCell((short) 1);
      cell.setCellValue("test of merging");

      //MEARGING CELLS 
      //this statement for merging cells

      spreadsheet.addMergedRegion(
         new CellRangeAddress(
            1, //first row (0-based)
            1, //last row (0-based)
            1, //first column (0-based)
            4 //last column (0-based)
         )
      );
      
      //CELL Alignment
      row = spreadsheet.createRow(5); 
      cell = (XSSFCell) row.createCell(0);
      row.setHeight((short) 800);
      
      // Top Left alignment 
      XSSFCellStyle style1 = workbook.createCellStyle();
      spreadsheet.setColumnWidth(0, 8000);
      style1.setAlignment(XSSFCellStyle.ALIGN_LEFT);
      style1.setVerticalAlignment(XSSFCellStyle.VERTICAL_TOP);
      cell.setCellValue("Top Left");
      cell.setCellStyle(style1);
      row = spreadsheet.createRow(6); 
      cell = (XSSFCell) row.createCell(1);
      row.setHeight((short) 800);
      
      // Center Align Cell Contents 
      XSSFCellStyle style2 = workbook.createCellStyle();
      style2.setAlignment(XSSFCellStyle.ALIGN_CENTER);
      style2.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
      cell.setCellValue("Center Aligned"); 
      cell.setCellStyle(style2);
      row = spreadsheet.createRow(7); 
      cell = (XSSFCell) row.createCell(2);
      row.setHeight((short) 800);
      
      // Bottom Right alignment 
      XSSFCellStyle style3 = workbook.createCellStyle();
      style3.setAlignment(XSSFCellStyle.ALIGN_RIGHT);
      style3.setVerticalAlignment(XSSFCellStyle.VERTICAL_BOTTOM);
      cell.setCellValue("Bottom Right");
      cell.setCellStyle(style3);
      row = spreadsheet.createRow(8);
      cell = (XSSFCell) row.createCell(3);
      
      // Justified Alignment 
      XSSFCellStyle style4 = workbook.createCellStyle();
      style4.setAlignment(XSSFCellStyle.ALIGN_JUSTIFY);
      style4.setVerticalAlignment(XSSFCellStyle.VERTICAL_JUSTIFY);
      cell.setCellValue("Contents are Justified in Alignment"); 
      cell.setCellStyle(style4);
      
      //CELL BORDER
      row = spreadsheet.createRow((short) 10);
      row.setHeight((short) 800);
      cell = (XSSFCell) row.createCell((short) 1);
      cell.setCellValue("BORDER");
      
      XSSFCellStyle style5 = workbook.createCellStyle();
      style5.setBorderBottom(XSSFCellStyle.BORDER_THICK);
      style5.setBottomBorderColor(IndexedColors.BLUE.getIndex());
      style5.setBorderLeft(XSSFCellStyle.BORDER_DOUBLE);
      style5.setLeftBorderColor(IndexedColors.GREEN.getIndex());
      style5.setBorderRight(XSSFCellStyle.BORDER_HAIR);
      style5.setRightBorderColor(IndexedColors.RED.getIndex());
      style5.setBorderTop(XSSFCellStyle.BIG_SPOTS);
      style5.setTopBorderColor(IndexedColors.CORAL.getIndex());
      cell.setCellStyle(style5);
      
      //Fill Colors
      //background color
      row = spreadsheet.createRow((short) 10 );
      cell = (XSSFCell) row.createCell((short) 1);
      
      XSSFCellStyle style6 = workbook.createCellStyle();
      style6.setFillBackgroundColor(HSSFColor.LEMON_CHIFFON.index );
      style6.setFillPattern(XSSFCellStyle.LESS_DOTS);
      style6.setAlignment(XSSFCellStyle.ALIGN_FILL);
      spreadsheet.setColumnWidth(1,8000);
      cell.setCellValue("FILL BACKGROUNG/FILL PATTERN");
      cell.setCellStyle(style6);
      
      //Foreground color
      row = spreadsheet.createRow((short) 12);
      cell = (XSSFCell) row.createCell((short) 1);
      
      XSSFCellStyle style7 = workbook.createCellStyle();
      style7.setFillForegroundColor(HSSFColor.BLUE.index);
      style7.setFillPattern( XSSFCellStyle.LESS_DOTS);
      style7.setAlignment(XSSFCellStyle.ALIGN_FILL);
      cell.setCellValue("FILL FOREGROUND/FILL PATTERN");
      cell.setCellStyle(style7);

      FileOutputStream out = new FileOutputStream(new File("cellstyle.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("cellstyle.xlsx written successfully");
   }
}

Enregistrez le code ci-dessus dans un fichier nommé CellStyle.java, compilez-le et exécutez-le à partir de l'invite de commande comme suit.

$javac CellStyle.java $java CellStyle

Il générera un fichier Excel nommé cellstyle.xlsx dans votre répertoire actuel et affichez la sortie suivante.

cellstyle.xlsx written successfully

Le fichier cellstyle.xlsx se présente comme suit.

Ce chapitre explique comment définir différentes polices, appliquer des styles et afficher du texte sous différents angles de direction dans une feuille de calcul Excel.

Chaque système est livré avec une énorme collection de polices telles que Arial, Impact, Times New Roman, etc. La collection peut également être mise à jour avec de nouvelles polices, si nécessaire. De même, il existe différents styles dans lesquels une police peut être affichée, par exemple, gras, italique, souligné, barré, etc.

Polices et styles de police

Le code suivant est utilisé pour appliquer une police et un style particuliers au contenu d'une cellule.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class FontStyle {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Fontstyle");
      XSSFRow row = spreadsheet.createRow(2);

      //Create a new font and alter it.
      XSSFFont font = workbook.createFont();
      font.setFontHeightInPoints((short) 30);
      font.setFontName("IMPACT");
      font.setItalic(true);
      font.setColor(HSSFColor.BRIGHT_GREEN.index);

      //Set font into style
      XSSFCellStyle style = workbook.createCellStyle();
      style.setFont(font);

      // Create a cell with a value and set style to it.
      XSSFCell cell = row.createCell(1);
      cell.setCellValue("Font Style");
      cell.setCellStyle(style);
      
      FileOutputStream out = new FileOutputStream(new File("fontstyle.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("fontstyle.xlsx written successfully");
   }
}

Sauvegardons le code ci-dessus dans un fichier nommé FontStyle.java. Compilez et exécutez-le à partir de l'invite de commande comme suit.

$javac FontStyle.java $java FontStyle

Il génère un fichier Excel nommé fontstyle.xlsx dans votre répertoire actuel et affichez la sortie suivante sur l'invite de commande.

fontstyle.xlsx written successfully

le fontstyle.xlsx Le fichier ressemble à ce qui suit.

Direction du texte

Ici, vous pouvez apprendre à définir la direction du texte sous différents angles. En général, le contenu des cellules est affiché horizontalement, de gauche à droite et à un angle 00; toutefois, vous pouvez utiliser le code suivant pour faire pivoter le sens du texte, si nécessaire.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class TextDirection {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Text direction");
      XSSFRow row = spreadsheet.createRow(2);
      XSSFCellStyle myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 0);
      XSSFCell cell = row.createCell(1);
      cell.setCellValue("0D angle");
      cell.setCellStyle(myStyle);

      //30 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 30);
      cell = row.createCell(3);
      cell.setCellValue("30D angle");
      cell.setCellStyle(myStyle);

      //90 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 90);
      cell = row.createCell(5);
      cell.setCellValue("90D angle");
      cell.setCellStyle(myStyle);

      //120 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 120);
      cell = row.createCell(7);
      cell.setCellValue("120D angle");
      cell.setCellStyle(myStyle);

      //270 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 270);
      cell = row.createCell(9);
      cell.setCellValue("270D angle");
      cell.setCellStyle(myStyle);

      //360 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 360);
      cell = row.createCell(12);
      cell.setCellValue("360D angle");
      cell.setCellStyle(myStyle);
      
      FileOutputStream out = new FileOutputStream(new File("textdirection.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("textdirection.xlsx written successfully");
   }
}

Conservez le code ci-dessus dans TextDirectin.java fichier, puis compilez-le et exécutez-le à partir de l'invite de commande comme suit.

$javac TextDirection.java $java TextDirection

Il se compilera et s'exécutera pour générer un fichier Excel nommé textdirection.xlsx dans votre répertoire actuel et affichez la sortie suivante sur l'invite de commande.

textdirection.xlsx written successfully

le textdirection.xlsx Le fichier ressemble à ce qui suit.

Ce chapitre vous guide tout au long du processus d'application de différentes formules sur des cellules à l'aide de la programmation Java. L'objectif de base de l'application Excel est de conserver les données numériques en appliquant des formules dessus.

Dans une formule, nous transmettons des valeurs dynamiques ou des emplacements des valeurs dans la feuille Excel. En exécutant cette formule, vous obtenez le résultat souhaité. Le tableau suivant répertorie quelques formules de base fréquemment utilisées dans Excel.

Opération	Syntaxe
Ajouter plusieurs numéros	= SOMME (Loc1: Locn) or = SOMME (n1, n2,)
Compter	= COUNT (Loc1: Locn) or = COUNT (n1, n2,)
Puissance de deux nombres	= PUISSANCE (Loc1, Loc2) or = PUISSANCE (nombre, puissance)
Max de plusieurs nombres	= MAX (Loc1: Locn) or = MAX (n1, n2,)
Produit	= PRODUIT (Loc1: Locn) or = PRODUIT (n1, n2,)
Factorielle	= FAIT (Locn) or = FAIT (nombre)
Nombre absolu	= ABS (Locn) or = ABS (nombre)
La date d'aujourd'hui	= AUJOURD'HUI ()
Convertit les minuscules	= INFÉRIEUR (Locn) or = LOWER (texte)
Racine carrée	= SQRT (locn) or = SQRT (nombre)

Le code suivant est utilisé pour ajouter des formules à une cellule et l'exécuter.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Formula {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("formula");
      XSSFRow row = spreadsheet.createRow(1);
      XSSFCell cell = row.createCell(1);
      
      cell.setCellValue("A = ");
      cell = row.createCell(2);
      cell.setCellValue(2);
      row = spreadsheet.createRow(2);
      cell = row.createCell(1);
      cell.setCellValue("B = ");
      cell = row.createCell(2);
      cell.setCellValue(4);
      row = spreadsheet.createRow(3);
      cell = row.createCell(1);
      cell.setCellValue("Total = ");
      cell = row.createCell(2);
      
      // Create SUM formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("SUM(C2:C3)");
      cell = row.createCell(3);
      cell.setCellValue("SUM(C2:C3)");
      row = spreadsheet.createRow(4);
      cell = row.createCell(1);
      cell.setCellValue("POWER =");
      cell=row.createCell(2);
      
      // Create POWER formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("POWER(C2,C3)");
      cell = row.createCell(3);
      cell.setCellValue("POWER(C2,C3)");
      row = spreadsheet.createRow(5);
      cell = row.createCell(1);
      cell.setCellValue("MAX = ");
      cell = row.createCell(2);
      
      // Create MAX formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("MAX(C2,C3)");
      cell = row.createCell(3);
      cell.setCellValue("MAX(C2,C3)");
      row = spreadsheet.createRow(6);
      cell = row.createCell(1);
      cell.setCellValue("FACT = ");
      cell = row.createCell(2);
      
      // Create FACT formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("FACT(C3)");
      cell = row.createCell(3);
      cell.setCellValue("FACT(C3)");
      row = spreadsheet.createRow(7);
      cell = row.createCell(1);
      cell.setCellValue("SQRT = ");
      cell = row.createCell(2);
      
      // Create SQRT formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("SQRT(C5)");
      cell = row.createCell(3);
      cell.setCellValue("SQRT(C5)");
      workbook.getCreationHelper().createFormulaEvaluator().evaluateAll();
      FileOutputStream out = new FileOutputStream(new File("formula.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("fromula.xlsx written successfully");
   }
}

Enregistrez le code ci-dessus sous Formula.java puis compilez et exécutez-le à partir de l'invite de commande comme suit.

$javac Formula.java $java Formula

Il générera un fichier Excel nommé formula.xlsx dans votre répertoire actuel et affichez la sortie suivante sur l'invite de commande.

fromula.xlsx written successfully

le formula.xlsx Le fichier ressemble à ce qui suit.

Ce chapitre explique comment ajouter des hyperliens au contenu d'une cellule. Les hyperliens sont généralement utilisés pour accéder à n'importe quelle URL Web, e-mail ou fichier externe.

Le code suivant montre comment créer des liens hypertexte sur des cellules.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.common.usermodel.Hyperlink;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFHyperlink;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class HyperlinkEX {
   public static void main(String[] args) throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Hyperlinks");
      XSSFCell cell;
      CreationHelper createHelper = workbook.getCreationHelper();
      XSSFCellStyle hlinkstyle = workbook.createCellStyle();
      XSSFFont hlinkfont = workbook.createFont();
      hlinkfont.setUnderline(XSSFFont.U_SINGLE);
      hlinkfont.setColor(HSSFColor.BLUE.index);
      hlinkstyle.setFont(hlinkfont);

      //URL Link
      cell = spreadsheet.createRow(1).createCell((short) 1);
      cell.setCellValue("URL Link");
      XSSFHyperlink link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_URL);
      link.setAddress("http://www.tutorialspoint.com/");
      cell.setHyperlink((XSSFHyperlink) link);
      cell.setCellStyle(hlinkstyle);

      //Hyperlink to a file in the current directory
      cell = spreadsheet.createRow(2).createCell((short) 1);
      cell.setCellValue("File Link");
      link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_FILE);
      link.setAddress("cellstyle.xlsx");
      cell.setHyperlink(link);
      cell.setCellStyle(hlinkstyle);

      //e-mail link
      cell = spreadsheet.createRow(3).createCell((short) 1);
      cell.setCellValue("Email Link");
      link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_EMAIL);
      link.setAddress("mailto:[email protected]?" + "subject = Hyperlink");
      cell.setHyperlink(link);
      cell.setCellStyle(hlinkstyle);
      
      FileOutputStream out = new FileOutputStream(new File("hyperlink.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("hyperlink.xlsx written successfully");
   }
}

Enregistrez le code ci-dessus sous HyperlinkEX.java. Compilez et exécutez-le à partir de l'invite de commande comme suit.

$javac HyperlinkEX.java $java HyperlinkEX

Il générera un fichier Excel nommé hyperlink.xlsx dans votre répertoire actuel et affichez la sortie suivante sur l'invite de commande.

hyperlink.xlsx written successfully

le hyperlink.xlsx Le fichier ressemble à ce qui suit.

Ce chapitre explique comment définir la zone d'impression sur une feuille de calcul. La zone d'impression habituelle est de haut à gauche en bas à droite sur les feuilles de calcul Excel. La zone d'impression peut être personnalisée selon vos besoins. Cela signifie que vous pouvez imprimer une plage particulière de cellules à partir de la feuille de calcul entière, personnaliser le format du papier, imprimer le contenu avec les lignes de la grille activées, etc.

Le code suivant est utilisé pour configurer la zone d'impression sur une feuille de calcul.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFPrintSetup;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class PrintArea {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Print Area");

      //set print area with indexes
      workbook.setPrintArea(
         0, //sheet index
         0, //start column
         5, //end column
         0, //start row
         5 //end row
      );
      
      //set paper size
      spreadsheet.getPrintSetup().setPaperSize(XSSFPrintSetup.A4_PAPERSIZE);
      
      //set display grid lines or not
      spreadsheet.setDisplayGridlines(true);
      
      //set print grid lines or not
      spreadsheet.setPrintGridlines(true);
      
      FileOutputStream out = new FileOutputStream(new File("printarea.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("printarea.xlsx written successfully"); 
   }
}

Sauvegardons le code ci-dessus sous PrintArea.java. Compilez et exécutez-le à partir de l'invite de commande comme suit.

$javac PrintArea.java $java PrintArea

Il générera un fichier nommé printarea.xlsx dans votre répertoire actuel et affichez la sortie suivante sur l'invite de commande.

printarea.xlsx written successfully

Dans le code ci-dessus, nous n'avons ajouté aucune valeur de cellule. Par conséquentprintarea.xlsxest un fichier vierge. Mais vous pouvez observer dans la figure suivante que l'aperçu avant impression montre la zone d'impression avec des lignes de quadrillage.

Ce chapitre explique comment la bibliothèque POI interagit avec une base de données. Avec l'aide de JDBC, vous pouvez récupérer des données d'une base de données et insérer ces données dans une feuille de calcul à l'aide de la bibliothèque POI. Considérons la base de données MySQL pour les opérations SQL.

Écrire dans Excel à partir de la base de données

Supposons que le tableau de données sur les employés suivant appelé emp_tbl doit être récupéré de la base de données MySQL test.

ID EMP	NOM EMP	DEG	UN SALAIRE	DEPT
1201	Gopal	Directeur technique	45 000	IL
1202	Manisha	Lecteur d'épreuves	45 000	Essai
1203	Masthanvali	Rédacteur technique	45 000	IL
1204	Kiran	Administrateur RH	40000	HEURE
1205	Kranthi	Administrateur des opérations	30000	Administrateur

Utilisez le code suivant pour récupérer des données dans une base de données et les insérer dans une feuille de calcul.

import java.io.File;
import java.io.FileOutputStream;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class ExcelDatabase {
   public static void main(String[] args) throws Exception {
      Class.forName("com.mysql.jdbc.Driver");
      Connection connect = DriverManager.getConnection( 
         "jdbc:mysql://localhost:3306/test" , 
         "root" , 
         "root"
      );
      
      Statement statement = connect.createStatement();
      ResultSet resultSet = statement.executeQuery("select * from emp_tbl");
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("employe db");
      
      XSSFRow row = spreadsheet.createRow(1);
      XSSFCell cell;
      cell = row.createCell(1);
      cell.setCellValue("EMP ID");
      cell = row.createCell(2);
      cell.setCellValue("EMP NAME");
      cell = row.createCell(3);
      cell.setCellValue("DEG");
      cell = row.createCell(4);
      cell.setCellValue("SALARY");
      cell = row.createCell(5);
      cell.setCellValue("DEPT");
      int i = 2;

      while(resultSet.next()) {
         row = spreadsheet.createRow(i);
         cell = row.createCell(1);
         cell.setCellValue(resultSet.getInt("eid"));
         cell = row.createCell(2);
         cell.setCellValue(resultSet.getString("ename"));
         cell = row.createCell(3);
         cell.setCellValue(resultSet.getString("deg"));
         cell = row.createCell(4);
         cell.setCellValue(resultSet.getString("salary"));
         cell = row.createCell(5);
         cell.setCellValue(resultSet.getString("dept"));
         i++;
      }

      FileOutputStream out = new FileOutputStream(new File("exceldatabase.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("exceldatabase.xlsx written successfully");
   }
}

Sauvegardons le code ci-dessus sous ExcelDatabase.java. Compilez et exécutez-le à partir de l'invite de commande comme suit.

$javac ExcelDatabase.java $java ExcelDatabase

Il générera un fichier Excel nommé exceldatabase.xlsx dans votre répertoire actuel et affichez la sortie suivante sur l'invite de commande.

exceldatabase.xlsx written successfully

le exceldatabase.xlsx Le fichier ressemble à ce qui suit.