Comment et où utiliser les itérateurs
Un objet d’une interface d’itérateur peut être utilisé pour traverser tous les éléments d’une collection. Les itérateurs peuvent être utilisés pour inspecter les données dans une collection, mais ils ne peuvent pas être utilisés pour modifier la collection sous-jacente. En général, pour utiliser un itérateur pour parcourir le contenu d’une collection, les étapes suivantes doivent être prises :
- Obtenir un itérateur au début de la collection en appelant la méthode d’itérateur de la collection.
- Mettre en place une boucle qui appelle la méthode hasNext. Faites en sorte que la boucle itère aussi longtemps que la méthode hasNext retourne vrai.
- À l’intérieur de la boucle, obtenir chaque élément en appelant la méthode next.
Les API Aspose.Cells fournissent un tas d’itérateurs, cependant, cet article discute principalement des trois types énumérés ci-dessous.
- Itérateur de cellules
- Itérateur de lignes
- Itérateur de colonnes
Comment utiliser les itérateurs
Itérateur de cellules
Il existe diverses façons d’accéder à l’itérateur de cellules, et l’on peut utiliser l’une de ces méthodes en fonction des besoins de l’application. Voici les méthodes qui retournent l’itérateur de cellules.
- Cells.iterator
- Row.iterator
- Range.iterator
Toutes les méthodes mentionnées ci-dessus renvoient l’itérateur qui permet de parcourir la collection de cellules qui ont été initialisées.
L’exemple de code suivant démontre la mise en œuvre de la classe Iterator pour une collection de cellules.
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java | |
String dataDir = Utils.getDataDir(CellsIterator.class); | |
// Load a file in an instance of Workbook | |
Workbook book = new Workbook(dataDir + "sample.xlsx"); | |
// Get the iterator from Cells collection | |
Iterator cellIterator = book.getWorksheets().get(0).getCells().iterator(); | |
// Traverse cells in the collection | |
while (cellIterator.hasNext()) { | |
Cell cell = (Cell) cellIterator.next(); | |
; | |
System.out.println(cell.getName() + " " + cell.getValue()); | |
} | |
// Get iterator from an object of Row | |
Iterator rowIterator = book.getWorksheets().get(0).getCells().getRows().get(0).iterator(); | |
// Traverse cells in the given row | |
while (rowIterator.hasNext()) { | |
Cell cell = (Cell) rowIterator.next(); | |
System.out.println(cell.getName() + " " + cell.getValue()); | |
} | |
// Get iterator from an object of Range | |
Iterator rangeIterator = book.getWorksheets().get(0).getCells().createRange("A1:B10").iterator(); | |
// Traverse cells in the range | |
while (rangeIterator.hasNext()) { | |
Cell cell = (Cell) rangeIterator.next(); | |
System.out.println(cell.getName() + " " + cell.getValue()); | |
} |
Itérateur de lignes
L’itérateur de lignes peut être accédé tout en utilisant la méthode RowCollection.iterator. L’exemple de code suivant démontre la mise en œuvre de l’itérateur pour la classe RowCollection.
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java | |
String dataDir = Utils.getDataDir(RowsIterator.class); | |
// Load a file in an instance of Workbook | |
Workbook book = new Workbook(dataDir + "sample.xlsx"); | |
// Get the iterator for RowCollection | |
Iterator rowsIterator = book.getWorksheets().get(0).getCells().getRows().iterator(); | |
// Traverse rows in the collection | |
while (rowsIterator.hasNext()) { | |
Row row = (Row) rowsIterator.next(); | |
System.out.println(row.getIndex()); | |
} |
Itérateur de colonnes
L’itérateur de colonnes peut être accédé tout en utilisant la méthode ColumnCollection.iterator. L’exemple de code suivant démontre la mise en œuvre de l’itérateur pour la classe ColumnCollection.
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java | |
String dataDir = Utils.getDataDir(ColumnsIterator.class); | |
// Load a file in an instance of Workbook | |
Workbook book = new Workbook(dataDir + "sample.xlsx"); | |
// Get the iterator for ColumnsCollection | |
Iterator colsIterator = book.getWorksheets().get(0).getCells().getColumns().iterator(); | |
// Traverse columns in the collection | |
while (colsIterator.hasNext()) { | |
Column col = (Column) colsIterator.next(); | |
System.out.println(col.getIndex()); | |
} |
Où utiliser les itérateurs
Pour discuter des avantages de l’utilisation des itérateurs, prenons un exemple concret.
Scénario
Une exigence de l’application est de parcourir toutes les cellules dans une feuille de calcul donnée pour lire leurs valeurs. Il pourrait y avoir plusieurs façons de mettre en œuvre cet objectif. Quelques-unes sont démontrées ci-dessous.
Utilisation de la plage d’affichage
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java | |
String dataDir = Utils.getDataDir(UsingDisplayRange.class); | |
// Load a file in an instance of Workbook | |
Workbook book = new Workbook(dataDir + "sample.xlsx"); | |
// Get Cells collection of first worksheet | |
Cells cells = book.getWorksheets().get(0).getCells(); | |
// Get the MaxDisplayRange | |
Range displayRange = cells.getMaxDisplayRange(); | |
// Loop over all cells in the MaxDisplayRange | |
for (int row = displayRange.getFirstRow(); row < displayRange.getRowCount(); row++) { | |
for (int col = displayRange.getFirstColumn(); col < displayRange.getColumnCount(); col++) { | |
// Read the Cell value | |
System.out.println(displayRange.get(row, col).getStringValue()); | |
} | |
} |
Utilisation de MaxDataRow & MaxDataColumn
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java | |
String dataDir = Utils.getDataDir(UsingMaxDataRowAndMaxDataColumn.class); | |
// Load a file in an instance of Workbook | |
Workbook book = new Workbook(dataDir + "sample.xlsx"); | |
// Get Cells collection of first worksheet | |
Cells cells = book.getWorksheets().get(0).getCells(); | |
// Loop over all cells | |
for (int row = 0; row < cells.getMaxDataRow(); row++) { | |
for (int col = 0; col < cells.getMaxDataColumn(); col++) { | |
// Read the Cell value | |
System.out.println(cells.get(row, col).getStringValue()); | |
} | |
} |
Comme vous pouvez le constater, les deux approches mentionnées ci-dessus utilisent plus ou moins une logique similaire, c’est-à-dire; parcourir toutes les cellules de la collection pour lire les valeurs des cellules. Cela pourrait poser problème pour un certain nombre de raisons comme discuté ci-dessous.
- Les API telles que MaxRow, MaxDataRow, MaxColumn, MaxDataColumn & MaxDisplayRange nécessitent du temps supplémentaire pour recueillir les statistiques correspondantes. Dans le cas où la matrice de données (ligne x colonnes) est grande, utiliser ces API pourrait entraîner une pénalité en termes de performances.
- Dans la plupart des cas, toutes les cellules dans une plage donnée ne sont pas instanciées. Dans de telles situations, vérifier chaque cellule dans la matrice n’est pas aussi efficace que de vérifier uniquement les cellules initialisées.
- Accéder à une cellule dans une boucle comme Cells.get(rowIndex, columnIndex) va provoquer l’instanciation de tous les objets de cellules dans une plage, ce qui pourrait éventuellement provoquer OutOfMemoryError.
Conclusion
Sur la base des faits mentionnés ci-dessus, voici les scénarios possibles où les itérateurs devraient être utilisés.
- L’accès en lecture seule à la collection de cellules est requis, c’est-à-dire; la seule exigence est d’inspecter les cellules.
- Un grand nombre de cellules doit être parcouru.
- Seules les cellules/rangées/colonnes initialisées doivent être parcourues.