Comment et où utiliser les itérateurs

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.

  1. Cells.iterator
  2. Row.iterator
  3. 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.

  1. 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.
  2. 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.
  3. 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.

  1. L’accès en lecture seule à la collection de cellules est requis, c’est-à-dire; la seule exigence est d’inspecter les cellules.
  2. Un grand nombre de cellules doit être parcouru.
  3. Seules les cellules/rangées/colonnes initialisées doivent être parcourues.