Come e dove utilizzare gli iteratori

Come utilizzare gli iteratori

Iteratore celle

Ci sono vari modi per accedere all’iteratore delle celle, e si può utilizzare uno qualsiasi di questi metodi in base alle esigenze dell’applicazione. Ecco i metodi che restituiscono l’iteratore delle celle.

  1. Cells.iterator
  2. Row.iterator
  3. Range.iterator

Tutti i metodi sopra menzionati restituiscono l’iteratore che consente di attraversare la collezione di celle che sono state inizializzate.

L’esempio di codice seguente dimostra l’implementazione della classe Iterator per una collezione di celle.

// 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());
}
Iteratore delle righe

L’Iteratore delle righe può essere accessibile utilizzando il metodo RowCollection.iterator. L’esempio di codice seguente dimostra l’implementazione dell’Iterator per 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());
}
Iteratore delle colonne

L’Iteratore delle colonne può essere accessibile utilizzando il metodo ColumnCollection.iterator. L’esempio di codice seguente dimostra l’implementazione dell’Iteratore per 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());
}

Dove utilizzare gli iteratori

Per discutere i vantaggi dell’utilizzo degli iteratori, prendiamo un esempio in tempo reale.

Scenario

Un requisito dell’applicazione è attraversare tutte le celle in un dato Foglio di lavoro per leggere i loro valori. Potrebbero esserci diversi modi per implementare questo obiettivo. Ne vengono dimostrati alcuni di seguito.

Utilizzo della gamma di visualizzazione
// 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());
}
}
Utilizzo di MaxDataRow e 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());
}
}

Come puoi osservare, entrambi i suddetti approcci utilizzano più o meno la stessa logica, cioè; iterare su tutte le celle nella collezione per leggere i valori delle celle. Questo potrebbe essere problematico per diversi motivi come discusso di seguito.

  1. Le API come MaxRow, MaxDataRow, MaxColumn, MaxDataColumn e MaxDisplayRange richiedono tempo aggiuntivo per raccogliere le statistiche corrispondenti. Nel caso la matrice dei dati (righe x colonne) sia ampia, utilizzare queste API potrebbe infliggere una penalità sulle prestazioni.
  2. Nella maggior parte dei casi, non tutte le celle in un dato intervallo sono istanziate. In tali situazioni controllare ogni cella nella matrice non è così efficiente rispetto al controllo solo delle celle inizializzate.
  3. L’accesso a una cella in un ciclo come Cells.get(rowIndex, columnIndex) causerà l’istanziazione di tutti gli oggetti cella in un intervallo, il che potrebbe alla fine causare OutOfMemoryError.
Conclusioni

Sulla base dei fatti sopra menzionati, di seguito sono riportati i possibili scenari in cui dovrebbero essere utilizzati gli iteratori.

  1. È richiesto l’accesso in sola lettura della raccolta di celle, cioè; il requisito è solo ispezionare le celle.
  2. È necessario attraversare un grande numero di celle.
  3. Devono essere attraversate solo celle/righe/colonne inizializzate.