Mise en forme des données

Approches pour formater les données dans les cellules

Il est communément admis que si les cellules de la feuille de calcul sont formatées correctement, il est plus facile pour les utilisateurs de lire le contenu (les données) de la cellule. Il existe de nombreuses façons de formater les cellules et leur contenu. La façon la plus simple est de formater les cellules en utilisant Microsoft Excel dans un environnement WYSIWYG lors de la création d’une feuille de calcul de concepteur. Une fois la feuille de calcul de concepteur créée, vous pouvez ouvrir la feuille de calcul en utilisant Aspose.Cells en conservant tous les paramètres de format enregistrés avec la feuille de calcul. Une autre façon de formater les cellules et leur contenu est d’utiliser l’API Aspose.Cells. Dans ce sujet, nous décrirons deux approches pour formater les cellules et leur contenu à l’aide de l’API Aspose.Cells.

Mise en forme des cellules

Les développeurs peuvent formater les cellules et leur contenu en utilisant l’API flexible d’Aspose.Cells. Aspose.Cells fournit une classe, Workbook, qui représente un fichier Microsoft Excel. La classe Workbook contient une WorksheetCollection qui permet d’accéder à chaque feuille de calcul dans un fichier Excel. Une feuille de calcul est représentée par la classe Worksheet. La classe Worksheet fournit une collection Cells. Chaque élément de la collection Cells représente un objet de la classe Cell.

Aspose.Cells fournit la propriété Style dans la classe Cell, utilisée pour définir le style de formatage d’une cellule. De plus, Aspose.Cells fournit également une classe Style utilisée pour le même but. Appliquez différents types de styles de formatage sur les cellules pour définir leurs couleurs d’arrière-plan ou de premier plan, les bordures, les polices, les alignements horizontal et vertical, le niveau d’indentation, la direction du texte, l’angle de rotation et bien plus encore.

Utilisation de la méthode setStyle

Lors de l’application de différents styles de formatage à différentes cellules, il est préférable d’utiliser la méthode setStyle de la classe Cell. Un exemple est donné ci-dessous pour illustrer l’utilisation de la méthode setStyle pour appliquer divers paramètres de formatage sur une cellule.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getDataDir(FormattingCellsUsingsetStyleMethod.class);
// Instantiating a Workbook object
Workbook workbook = new Workbook(dataDir + "book1.xls");

// Accessing the first worksheet in the Excel file
Worksheet worksheet = workbook.getWorksheets().get(0);
Cells cells = worksheet.getCells();

// Accessing the "A1" cell from the worksheet
Cell cell = cells.get("A1");

// Adding some value to the "A1" cell
cell.setValue("Hello Aspose!");

Style style = cell.getStyle();

// Setting the vertical alignment of the text in the "A1" cell
style.setVerticalAlignment(TextAlignmentType.CENTER);

// Setting the horizontal alignment of the text in the "A1" cell
style.setHorizontalAlignment(TextAlignmentType.CENTER);

// Setting the font color of the text in the "A1" cell
Font font = style.getFont();
font.setColor(Color.getGreen());

// Setting the cell to shrink according to the text contained in it
style.setShrinkToFit(true);

// Setting the bottom border
style.setBorder(BorderType.BOTTOM_BORDER, CellBorderType.MEDIUM, Color.getRed());

// Saved style
cell.setStyle(style);

// Saving the modified Excel file in default (that is Excel 2003) format
workbook.save(dataDir + "output.xls");

Utilisation de l’objet Style

Lors de l’application du même style de formatage à différentes cellules, utilisez l’objet Style.

1. Ajoutez un objet Style à la collection Styles de la classe Workbook en appelant la méthode createStyle de la classe Workbook.
2. Accédez au nouvel objet Style ajouté depuis la collection Styles.
3. Définissez les propriétés souhaitées de l’objet Style pour appliquer les paramètres de formatage souhaités.
4. Attribuez l’objet Style configuré à la propriété Style de n’importe quelle cellule souhaitée.

Cette approche peut grandement améliorer l’efficacité de vos applications et économiser de la mémoire également.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(FormattingCellsUsingStyleObject.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook(dataDir + "book1.xls");

// Accessing the first worksheet in the Excel file
Worksheet worksheet = workbook.getWorksheets().get(0);
Cells cells = worksheet.getCells();

// Accessing the "A1" cell from the worksheet
Cell cell = cells.get("A1");

// Adding some value to the "A1" cell
cell.setValue("Hello Aspose!");

// Adding a new Style to the styles collection of the Excel object
Style style = workbook.createStyle();

// Setting the vertical alignment of the text in the "A1" cell
style.setVerticalAlignment(TextAlignmentType.CENTER);

// Setting the horizontal alignment of the text in the "A1" cell
style.setHorizontalAlignment(TextAlignmentType.CENTER);

// Setting the font color of the text in the "A1" cell
Font font = style.getFont();
font.setColor(Color.getGreen());

// Setting the cell to shrink according to the text contained in it
style.setShrinkToFit(true);

// Setting the bottom border
style.setBorder(BorderType.BOTTOM_BORDER, CellBorderType.MEDIUM, Color.getRed());

// Saved style
cell.setStyle(style);

// Saving the modified Excel file in default format
workbook.save(dataDir + "FCUsingStyleObject_out.xls");

Application d’effets de remplissage dégradé

Pour appliquer les effets de remplissage en dégradé désirés à la cellule, utilisez la méthode setTwoColorGradient de l’objet Style en conséquence.

Exemple de code

La sortie suivante est obtenue en exécutant le code ci-dessous.

Application des effets de remplissage en dégradé

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(ApplyGradientFillEffects.class) + "data/";
// Instantiate a new Workbook
Workbook workbook = new Workbook();
// Get the first worksheet (default) in the workbook
Worksheet worksheet = workbook.getWorksheets().get(0);
// Input a value into B3 cell
worksheet.getCells().get(2, 1).putValue("test");

// Get the Style of the cell
Style style = worksheet.getCells().get("B3").getStyle();
// Set Gradient pattern on
style.setGradient(true);
// Specify two color gradient fill effects
style.setTwoColorGradient(Color.fromArgb(255, 255, 255), Color.fromArgb(79, 129, 189),
		GradientStyleType.HORIZONTAL, 1);
// Set the color of the text in the cell
style.getFont().setColor(Color.getRed());
// Specify horizontal and vertical alignment settings
style.setHorizontalAlignment(TextAlignmentType.CENTER);
style.setVerticalAlignment(TextAlignmentType.CENTER);

// Apply the style to the cell
worksheet.getCells().get("B3").setStyle(style);

// Set the third row height in pixels
worksheet.getCells().setRowHeightPixel(2, 53);

// Merge the range of cells (B3:C3)
worksheet.getCells().merge(2, 1, 1, 2);

// Save the Excel file
workbook.save(dataDir + "ApplyGradientFillEffects_out.xlsx");

Configuration des paramètres d’alignement

Toute personne ayant utilisé Microsoft Excel pour formater des cellules sera familière avec les paramètres d’alignement dans Microsoft Excel.

Paramètres d’alignement dans Microsoft Excel

Comme vous pouvez le voir sur la figure ci-dessus, il existe différents types d’options d’alignement :

• Alignement du texte (horizontal & vertical)
• Indentation
• Orientation
• Contrôle du texte
• Direction du texte

Tous ces paramètres d’alignement sont entièrement pris en charge par Aspose.Cells et sont discutés plus en détail ci-dessous.

Configuration des paramètres d’alignement

Aspose.Cells fournit une classe, Workbook, qui représente un fichier Excel. La classe Workbook contient une WorksheetCollection qui permet d’accéder à chaque feuille de calcul du fichier Excel. Une feuille de calcul est représentée par la classe Worksheet.

La classe Worksheet fournit une collection Cells. Chaque élément de la collection Cells représente un objet de la classe Cell.

Aspose.Cells fournit la méthode setStyle dans la classe Cell qui est utilisée pour formater une cellule. La classe Style fournit des propriétés utiles pour configurer les paramètres de la police.

Sélectionnez n’importe quel type d’alignement de texte en utilisant l’énumération TextAlignmentType. Les types d’alignement de texte prédéfinis dans l’énumération TextAlignmentType sont :

Types d’alignement de texte	Description
Bottom	Représente un alignement de texte en bas
Center	Représente un alignement de texte au centre
CenterAcross	Représente un alignement de texte centré sur plusieurs cellules
Distributed	Représente un alignement de texte distribué
Fill	Représente un alignement de texte en remplissage
General	Représente un alignement de texte général
Justify	Représente un alignement de texte justifié
Left	Représente un alignement de texte à gauche
Right	Représente un alignement de texte à droite
Top	Représente un alignement de texte en haut
Vous pouvez également appliquer le paramètre de justifie distribué en utilisant la méthode Style.setJustifyDistributed().

Alignement horizontal

Utilisez la méthode setHorizontalAlignment de l’objet Style pour aligner le texte horizontalement.

La sortie suivante est obtenue en exécutant le code d’exemple ci-dessous :

Aligner le texte horizontalement

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(TextAlignmentHorizontal.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
int sheetIndex = workbook.getWorksheets().add();
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);
Cells cells = worksheet.getCells();

// Adding the current system date to "A1" cell
Cell cell = cells.get("A1");
Style style = cell.getStyle();

// Adding some value to the "A1" cell
cell.setValue("Visit Aspose!");

// Setting the horizontal alignment of the text in the "A1" cell
style.setHorizontalAlignment(TextAlignmentType.CENTER);

// Saved style
cell.setStyle(style);

// Saving the modified Excel file in default format
workbook.save(dataDir + "TAHorizontal_out.xls");

Alignement vertical

Utilisez la méthode setVerticalAlignment de l’objet Style pour aligner le texte verticalement.

La sortie suivante est obtenue lorsque VerticalAlignment est défini sur centre.

Aligner le texte verticalement

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(TextAlignmentVertical.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
int sheetIndex = workbook.getWorksheets().add();
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);
Cells cells = worksheet.getCells();

// Adding the current system date to "A1" cell
Cell cell = cells.get("A1");
Style style = cell.getStyle();

// Adding some value to the "A1" cell
cell.setValue("Visit Aspose!");

// Setting the vertical alignment of the text in a cell
Style style1 = cell.getStyle();
style1.setVerticalAlignment(TextAlignmentType.CENTER);
cell.setStyle(style1);

// Saved style
cell.setStyle(style1);

// Saving the modified Excel file in default format
workbook.save(dataDir + "TAVertical_out.xls");

Indentation

Il est possible de définir le niveau d’indentation du texte dans une cellule en utilisant la méthode setIndentLevel de l’objet Style.

La sortie suivante est obtenue lorsque IndentLevel est défini sur 2.

Niveau d’indentation ajusté à 2

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(Indentation.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
int sheetIndex = workbook.getWorksheets().add();
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);
Cells cells = worksheet.getCells();

// Adding the current system date to "A1" cell
Cell cell = cells.get("A1");
Style style = cell.getStyle();

// Adding some value to the "A1" cell
cell.setValue("Visit Aspose!");

// Setting the vertical alignment of the text in a cell
Style style1 = cell.getStyle();
style1.setIndentLevel(2);
cell.setStyle(style1);

// Saved style
cell.setStyle(style1);

// Saving the modified Excel file in default format
workbook.save(dataDir + "Indentation_out.xls");

Orientation

Définir l’orientation (rotation) du texte dans une cellule avec la méthode setRotationAngle de l’objet Style.

La sortie suivante est obtenue lorsque l’angle de rotation est défini sur 25.

Angle de rotation défini à 25

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(Orientation.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
int sheetIndex = workbook.getWorksheets().add();
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);
Cells cells = worksheet.getCells();

// Adding the current system date to "A1" cell
Cell cell = cells.get("A1");
Style style = cell.getStyle();

// Adding some value to the "A1" cell
cell.setValue("Visit Aspose!");

// Setting the rotation of the text (inside the cell) to 25
Style style1 = cell.getStyle();
style1.setRotationAngle(25);
cell.setStyle(style1);

// Saved style
cell.setStyle(style1);

// Saving the modified Excel file in default format
workbook.save(dataDir + "Orientation_out.xls");

Contrôle du texte

La section suivante aborde comment contrôler le texte en définissant le retour à la ligne, le rétrécissement pour s’adapter et d’autres options de mise en forme.

Retour à la ligne du texte

Le retour à la ligne du texte dans une cellule rend la lecture plus facile : la hauteur de la cellule s’ajuste pour s’adapter à tout le texte, au lieu de le couper ou de déborder sur les cellules voisines.

Activez ou désactivez le retour à la ligne avec la méthode Style de l’objet setTextWrapped.

Le résultat suivant est obtenu lorsque le retour à la ligne du texte est activé.

Texte retourné à l’intérieur de la cellule

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(WrapText.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
int sheetIndex = workbook.getWorksheets().add();
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);
Cells cells = worksheet.getCells();

// Adding the current system date to "A1" cell
Cell cell = cells.get("A1");
Style style = cell.getStyle();

// Adding some value to the "A1" cell
cell.setValue("Visit Aspose!");

// Enabling the text to be wrapped within the cell
Style style1 = cell.getStyle();
style1.setTextWrapped(true);
cell.setStyle(style1);

// Saved style
cell.setStyle(style1);

// Saving the modified Excel file in default format
workbook.save(dataDir + "WrapText_out.xls");

Rétrécissement pour s’adapter

Une option pour le retour à la ligne du texte dans un champ est de réduire la taille du texte pour qu’il tienne dans les dimensions d’une cellule. Ceci est fait en définissant la propriété IsTextWrapped de l’objet Style sur true.

Le résultat suivant est obtenu lorsque le texte est réduit pour tenir dans la cellule.

Texte rétréci pour tenir à l’intérieur des limites de la cellule

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(ShrinkingToFit.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
int sheetIndex = workbook.getWorksheets().add();
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);
Cells cells = worksheet.getCells();

// Adding the current system date to "A1" cell
Cell cell = cells.get("A1");
Style style = cell.getStyle();

// Adding some value to the "A1" cell
cell.setValue("Visit Aspose!");

// Shrinking the text to fit according to the dimensions of the cell
Style style1 = cell.getStyle();
style1.setShrinkToFit(true);
cell.setStyle(style1);

// Saved style
cell.setStyle(style1);

// Saving the modified Excel file in default format
workbook.save(dataDir + "ShrinkingToFit_out.xls");

Fusion de cellules

Comme Microsoft Excel, Aspose.Cells prend en charge la fusion de plusieurs cellules en une seule.

Le résultat suivant est obtenu si les trois cellules de la première ligne sont fusionnées pour créer une seule grande cellule.

Trois cellules fusionnées pour créer une grande cellule

Utilisez la méthode Merge de la collection Cells pour fusionner des cellules. La méthode Merge prend les paramètres suivants :

• Première ligne, la première ligne à partir de laquelle commencer la fusion.
• Première colonne, la première colonne à partir de laquelle commencer la fusion.
• Nombre de lignes, le nombre de lignes à fusionner. Nombre de colonnes, le nombre de colonnes à fusionner.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(MergingCellsInWorksheet.class) + "data/";

// Create a Workbook.
Workbook wbk = new Workbook();

// Create a Worksheet and get the first sheet.
Worksheet worksheet = wbk.getWorksheets().get(0);

// Create a Cells object to fetch all the cells.
Cells cells = worksheet.getCells();

// Merge some Cells (C6:E7) into a single C6 Cell.
cells.merge(5, 2, 2, 3);

// Input data into C6 Cell.
worksheet.getCells().get(5, 2).setValue("This is my value");

// Create a Style object to fetch the Style of C6 Cell.
Style style = worksheet.getCells().get(5, 2).getStyle();

// Create a Font object
Font font = style.getFont();

// Set the name.
font.setName("Times New Roman");

// Set the font size.
font.setSize(18);

// Set the font color
font.setColor(Color.getBlue());

// Bold the text
font.setBold(true);

// Make it italic
font.setItalic(true);

// Set the backgrond color of C6 Cell to Red
style.setForegroundColor(Color.getRed());
style.setPattern(BackgroundType.SOLID);

// Apply the Style to C6 Cell.
cells.get(5, 2).setStyle(style);

// Save the Workbook.
wbk.save(dataDir + "mergingcells_out.xls");
wbk.save(dataDir + "mergingcells_out.xlsx");
wbk.save(dataDir + "mergingcells_out.ods");

// Print message
System.out.println("Process completed successfully");

Direction du texte

Il est possible de définir l’ordre de lecture du texte dans les cellules. L’ordre de lecture est l’ordre visuel dans lequel les caractères, les mots, etc. sont affichés. Par exemple, l’anglais est une langue de gauche à droite tandis que l’arabe est une langue de droite à gauche.

L’ordre de lecture est défini avec la propriété TextDirection de l’objet Style. Aspose.Cells fournit des types de direction de texte prédéfinis dans l’énumération TextDirectionType.

Types de direction du texte	Description
Context	L’ordre de lecture en accord avec la langue du premier caractère saisi
LeftToRight	Ordre de lecture de gauche à droite
RightToLeft	Ordre de lecture de droite à gauche

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(ChangeTextDirection.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
int sheetIndex = workbook.getWorksheets().add();
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);
Cells cells = worksheet.getCells();

// Adding the current system date to "A1" cell
Cell cell = cells.get("A1");
Style style = cell.getStyle();

// Adding some value to the "A1" cell
cell.setValue("Visit Aspose!");

// Setting the text direction from right to left
Style style1 = cell.getStyle();
style1.setTextDirection(TextDirectionType.RIGHT_TO_LEFT);
cell.setStyle(style1);
// Saved style
cell.setStyle(style1);

// Saving the modified Excel file in default format
workbook.save(dataDir + "ChangeTextDirection_out.xls");

La sortie suivante est obtenue si l’ordre de lecture du texte est défini de droite à gauche.

Définir l’ordre de lecture du texte de droite à gauche

Formatage de caractères sélectionnés dans une cellule

Traitement des paramètres de police a expliqué comment formater des cellules mais seulement comment formater le contenu complet des cellules. Et si vous voulez formater uniquement certains caractères ?

Aspose.Cells prend en charge cette fonctionnalité. Ce sujet explique comment l’utiliser.

Formatage de caractères sélectionnés

Aspose.Cells fournit une classe, Workbook, qui représente un fichier Microsoft Excel. La classe Workbook contient une collection de feuilles de calcul qui permet d’accéder à chaque feuille de calcul dans le fichier Excel. Une feuille de calcul est représentée par la classe Worksheet. La classe Worksheet fournit une collection de cellules. Chaque élément de la collection Cells représente un objet de la classe Cell.

La classe Cell fournit une méthode characters qui prend les paramètres suivants pour sélectionner une plage de caractères dans une cellule :

• Index de départ, l’index du caractère à partir duquel commencer la sélection.
• Nombre de caractères, le nombre de caractères à sélectionner.

Dans le fichier de sortie, dans la cellule A1, le mot ‘Visite’ est formaté avec la police par défaut mais ‘Aspose!’ est en gras et en bleu.

Mise en forme des caractères sélectionnés

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// Path to source file
String dataDir = Utils.getSharedDataDir(FormattingSelectedCharacters.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
int sheetIndex = workbook.getWorksheets().add();
Worksheet worksheet = workbook.getWorksheets().get(sheetIndex);
Cells cells = worksheet.getCells();

// Adding some value to the "A1" cell
Cell cell = cells.get("A1");
cell.setValue("Visit Aspose!");

Font font = cell.characters(6, 7).getFont();

// Setting the font of selected characters to bold
font.setBold(true);

// Setting the font color of selected characters to blue
font.setColor(Color.getBlue());

// Saving the Excel file
workbook.save(dataDir + "FSCharacters_out.xls");

Si vous êtes intéressé par la mise en forme d’une partie du Rich Text dans une cellule, considérez l’utilisation des méthodes Cell.getCharacters & Cell.setCharacters. La méthode Cell.getCharacters est utilisée pour accéder aux parties du texte et les modifications peuvent être effectuées en utilisant la méthode Cell.setCharacters tandis que la méthode get renvoie un tableau d’objets FontSetting qui peuvent être manipulés pour définir diverses propriétés telles que le nom de la police, la couleur de la police, la graisse, etc, et la méthode set peut être utilisée pour appliquer les modifications.

Activation des feuilles et mise en place d’une cellule active ou sélection d’une plage de cellules dans la feuille de calcul

Parfois, vous pouvez avoir besoin d’activer une feuille de calcul spécifique afin qu’elle soit la première à s’afficher lorsque quelqu’un ouvre le fichier dans Microsoft Excel. Vous pouvez également avoir besoin d’activer une cellule spécifique de manière à ce que les barres de défilement se déplacent vers la cellule active pour qu’elle soit clairement visible. Aspose.Cells est capable d’effectuer toutes les tâches mentionnées ci-dessus.

Une feuille active est la feuille sur laquelle vous travaillez dans un classeur. Le nom de l’onglet de la feuille active est en gras par défaut. Une cellule active, quant à elle, est la cellule sélectionnée dans laquelle les données sont saisies lorsque vous commencez à taper. Seule une cellule est active à la fois. La cellule active est entourée d’une bordure épaisse pour la faire ressortir des autres cellules. Aspose.Cells vous permet également de sélectionner une plage de cellules dans la feuille de calcul.

Activation d’une feuille et mise en place d’une cellule active

Aspose.Cells fournit une API spécifique pour ces tâches. Par exemple, la méthode WorksheetCollection.setActiveSheetIndex est utile pour définir une feuille active. De même, la méthode Worksheet.setActiveCell est utilisée pour définir et obtenir une cellule active dans une feuille de calcul.

Si vous souhaitez que les barres de défilement horizontales et verticales se déplacent jusqu’à la position de l’index de ligne et de colonne pour donner une bonne vue des données sélectionnées lorsque le fichier est ouvert dans Microsoft Excel, utilisez les propriétés Worksheet.setFirstVisibleRow et Worksheet.setFirstVisibleColumn.

L’exemple suivant montre comment activer une feuille de calcul et rendre une cellule active. Les barres de défilement sont déplacées pour faire de la 2e ligne et de la 2e colonne leur première ligne et colonne visible.

Définition de la cellule B2 comme cellule active

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(MakeCellActive.class) + "data/";
// Instantiate a new Workbook.
Workbook workbook = new Workbook();

// Get the first worksheet in the workbook.
Worksheet worksheet1 = workbook.getWorksheets().get(0);

// Get the cells in the worksheet.
Cells cells = worksheet1.getCells();

// Input data into B2 cell.
cells.get(1, 1).setValue("Hello World!");

// Set the first sheet as an active sheet.
workbook.getWorksheets().setActiveSheetIndex(0);

// Set B2 cell as an active cell in the worksheet.
worksheet1.setActiveCell("B2");

// Set the B column as the first visible column in the worksheet.
worksheet1.setFirstVisibleColumn(1);

// Set the 2nd row as the first visible row in the worksheet.
worksheet1.setFirstVisibleRow(1);

// Save the Excel file.
workbook.save(dataDir + "MakeCellActive_out.xls");

Sélection d’une plage de cellules dans la feuille de calcul

Aspose.Cells fournit la méthode Worksheet.selectRange(int startRow, int startColumn, int totalRows, int totalColumns, bool removeOthers). En utilisant le dernier paramètre - removeOthers - à true, les autres sélections de cellules ou de plages de cellules dans la feuille sont supprimées.

L’exemple suivant montre comment sélectionner une plage de cellules dans la feuille de calcul active.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(SelectRangeofCellsinWorksheet.class) + "data/";
// Instantiate a new Workbook.
Workbook workbook = new Workbook();

// Get the first worksheet in the workbook.
Worksheet worksheet1 = workbook.getWorksheets().get(0);

// Get the cells in the worksheet.
Cells cells = worksheet1.getCells();

// Input data into B2 cell.
cells.get(1, 1).setValue("Hello World!");

// Set the first sheet as an active sheet.
workbook.getWorksheets().setActiveSheetIndex(0);

// Select range of cells(A1:E10) in the worksheet.
worksheet1.selectRange(0, 0, 10, 5, true);

// Save the Excel file.
workbook.save(dataDir + "SROfCInWorksheet_out.xlsx");

Toutes les classes et méthodes ci-dessus sont disponibles avec la version sous licence de Aspose.Cells.

Formatage des lignes et colonnes

Mettre en forme les lignes et les colonnes dans une feuille de calcul pour donner au rapport un aspect est probablement la fonctionnalité la plus largement utilisée de l’application Excel. Les API Aspose.Cells offrent également cette fonctionnalité grâce à son modèle de données en exposant la classe Style qui gère principalement toutes les fonctionnalités liées au style telles que la police et ses attributs, l’alignement du texte, les couleurs de fond/avant-plan, les bordures, le format d’affichage pour les chiffres et les littéraux de date, etc. Une autre classe utile fournie par les API Aspose.Cells est StyleFlag qui permet la réutilisation de l’objet Style. 

Dans cet article, nous essaierons d’expliquer comment utiliser l’API Aspose.Cells for Java pour appliquer une mise en forme aux lignes et aux colonnes. 

Mise en forme des lignes & colonnes

Aspose.Cells fournit une classe, Workbook qui représente un fichier Microsoft Excel. La classe Workbook contient une WorksheetCollection qui permet d’accéder à chaque feuille de calcul du fichier Excel. Une feuille de calcul est représentée par la classe Worksheet. La classe Worksheet fournit la collection Cells.

Formatage d’une ligne

Chaque élément de la collection Rows représente un objet Row. L’objet Row offre la méthode applyStyle utilisée pour appliquer une mise en forme à une ligne.

Pour appliquer le même formatage à une ligne, utilisez l’objet Style :

1. Ajoutez un objet Style à la classe Workbook en appelant sa méthode createStyle.
2. Définissez les propriétés de l’objet Style pour appliquer les paramètres de formatage.
3. Assignez l’objet Style configuré à la méthode applyStyle d’un objet Row.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(FormattingARow.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
Worksheet worksheet = workbook.getWorksheets().get(0);
Cells cells = worksheet.getCells();

// Adding a new Style to the styles collection of the Excel object Accessing the newly added Style to the Excel object
Style style = workbook.createStyle();

// Setting the vertical alignment of the text in the cell
style.setVerticalAlignment(TextAlignmentType.CENTER);

// Setting the horizontal alignment of the text in the cell
style.setHorizontalAlignment(TextAlignmentType.CENTER);

// Setting the font color of the text in the cell
Font font = style.getFont();
font.setColor(Color.getGreen());

// Shrinking the text to fit in the cell
style.setShrinkToFit(true);

// Setting the bottom border of the cell
style.setBorder(BorderType.BOTTOM_BORDER, CellBorderType.MEDIUM, Color.getRed());

// Creating StyleFlag
StyleFlag styleFlag = new StyleFlag();
styleFlag.setHorizontalAlignment(true);
styleFlag.setVerticalAlignment(true);
styleFlag.setShrinkToFit(true);
styleFlag.setBottomBorder(true);
styleFlag.setFontColor(true);

// Accessing a row from the Rows collection
Row row = cells.getRows().get(0);

// Assigning the Style object to the Style property of the row
row.applyStyle(style, styleFlag);

// Saving the Excel file
workbook.save(dataDir + "FormattingARow_out.xls");

Formatage d’une colonne

La collection Cells fournit une collection Columns. Chaque élément de la collection Columns représente un objet Column. Similaire à l’objet Row, l’objet Column offre la méthode applyStyle utilisée pour définir le formatage de la colonne. Utilisez la méthode applyStyle de l’objet Column pour formater une colonne de la même manière qu’une ligne.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(FormattingAColumn.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Accessing the added worksheet in the Excel file
Worksheet worksheet = workbook.getWorksheets().get(0);
Cells cells = worksheet.getCells();

// Adding a new Style to the styles collection of the Excel object Accessing the newly added Style to the Excel object
Style style = workbook.createStyle();

// Setting the vertical alignment of the text in the cell
style.setVerticalAlignment(TextAlignmentType.CENTER);

// Setting the horizontal alignment of the text in the cell
style.setHorizontalAlignment(TextAlignmentType.CENTER);

// Setting the font color of the text in the cell
Font font = style.getFont();
font.setColor(Color.getGreen());

// Shrinking the text to fit in the cell
style.setShrinkToFit(true);

// Setting the bottom border of the cell
style.setBorder(BorderType.BOTTOM_BORDER, CellBorderType.MEDIUM, Color.getRed());

// Creating StyleFlag
StyleFlag styleFlag = new StyleFlag();
styleFlag.setHorizontalAlignment(true);
styleFlag.setVerticalAlignment(true);
styleFlag.setShrinkToFit(true);
styleFlag.setBottomBorder(true);
styleFlag.setFontColor(true);

// Accessing a column from the Columns collection
Column column = cells.getColumns().get(0);

// Applying the style to the column
column.applyStyle(style, styleFlag);

// Saving the Excel file
workbook.save(dataDir + "FormattingAColumn_out.xls");

Définir le format d’affichage des chiffres et des dates pour les lignes et les colonnes

Si l’exigence est de définir le format d’affichage des chiffres et des dates pour une ligne ou une colonne complète, le processus est plus ou moins le même que celui discuté ci-dessus, cependant, au lieu de définir des paramètres pour le contenu textuel, vous définirez le formatage pour les chiffres et les dates en utilisant le Style.Number ou le Style.Custom. Veuillez noter que la propriété Style.Number est de type entier et fait référence aux formats de nombre et de date intégrés, tandis que la propriété Style.Custom est de type chaîne et accepte les modèles valides.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(SettingDisplayFormat.class) + "data/";
// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Obtaining the reference of the first (default) worksheet by passing its sheet index
Worksheet worksheet = workbook.getWorksheets().get(0);

// Adding a new Style to the styles collection of the Workbook object
Style style = workbook.createStyle();

// Setting the Number property to 4 which corresponds to the pattern #,##0.00
style.setNumber(4);

// Creating an object of StyleFlag
StyleFlag flag = new StyleFlag();

// Setting NumberFormat property to true so that only this aspect takes effect from Style object
flag.setNumberFormat(true);

// Applying style to the first row of the worksheet
worksheet.getCells().getRows().get(0).applyStyle(style, flag);

// Re-initializing the Style object
style = workbook.createStyle();

// Setting the Custom property to the pattern d-mmm-yy
style.setCustom("d-mmm-yy");

// Applying style to the first column of the worksheet
worksheet.getCells().getColumns().get(0).applyStyle(style, flag);

// Saving spreadsheet on disc
workbook.save(dataDir + "SDisplayFormat_out.xlsx");

Veuillez consulter l’article détaillé sur [Réglage des formats d’affichage des chiffres et des Dates.