Come e dove usare gli iteratori

Un oggetto di un’interfaccia iteratore può essere utilizzato per attraversare tutti gli elementi di una raccolta. Gli iteratori possono essere utilizzati per ispezionare i dati in una raccolta, ma non possono essere utilizzati per modificare la raccolta sottostante. In generale, per utilizzare un iteratore per scorrere i contenuti di una raccolta, è necessario eseguire i seguenti passaggi:

1. Ottenere un iteratore all’inizio della raccolta chiamando il metodo iteratore della raccolta.
2. Imposta un ciclo che effettua una chiamata al metodo hasNext. Fai iterare il ciclo finché il metodo hasNext restituisce true.
3. All’interno del ciclo, ottenere ogni elemento chiamando il metodo next.

Aspose.Cells Le API forniscono una serie di iteratori, tuttavia, questo articolo discute principalmente i tre tipi elencati di seguito.

1. Cells Iteratore
2. Iteratore di righe
3. Iteratore di colonne

Come usare gli iteratori

Cells Iteratore

Esistono vari modi per accedere all’iteratore delle celle e si può utilizzare uno qualsiasi di questi metodi in base ai requisiti dell’applicazione. Ecco i metodi che restituiscono l’iteratore delle celle.

1. Cells.iterator
2. Riga.iteratore
3. Intervallo.iteratore

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

Durante l’attraversamento delle celle, la raccolta non deve essere modificata (operazioni che causeranno l’istanziazione di un nuovo Cell o l’eliminazione di Cell esistente). In caso contrario, l’iteratore potrebbe non essere in grado di attraversare correttamente tutte le celle (alcuni elementi potrebbero essere attraversati ripetutamente o ignorati).

Nell’esempio di codice seguente viene illustrata l’implementazione della classe Iterator per una raccolta 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 di righe

È possibile accedere a Rows Iterator durante l’utilizzo del metodo RowCollection.iterator. Nell’esempio di codice seguente viene illustrata l’implementazione della classe Iterator per 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 di colonne

È possibile accedere a Columns Iterator durante l’utilizzo del metodo ColumnCollection.iterator. Nell’esempio di codice seguente viene illustrata l’implementazione della classe Iterator per 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 usare gli iteratori

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

Scenario

Un requisito dell’applicazione è attraversare tutte le celle in un determinato foglio di lavoro per leggerne i valori. Ci potrebbero essere diversi modi per implementare questo obiettivo. Alcuni sono dimostrati di seguito.

Utilizzo dell’intervallo 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 gli approcci sopra menzionati utilizzano una logica più o meno simile, ovvero; eseguire il ciclo su tutte le celle della raccolta per leggere i valori delle celle. Questo potrebbe essere problematico per una serie di motivi come discusso di seguito.

1. Le API come MaxRow, MaxDataRow, MaxColumn, MaxDataColumn e MaxDisplayRange richiedono più tempo per raccogliere le statistiche corrispondenti. Nel caso in cui la matrice di dati (righe x colonne) sia grande, l’utilizzo di queste API potrebbe imporre una riduzione delle prestazioni.
2. Nella maggior parte dei casi, non tutte le celle in un determinato intervallo vengono istanziate. In tali situazioni controllare ogni cella della matrice non è così efficiente rispetto a controllare solo le celle inizializzate.
3. L’accesso a una cella in un ciclo come Cells.get(rowIndex, columnIndex) causerà la creazione di un’istanza di tutti gli oggetti cella in un intervallo, che alla fine potrebbe causare OutOfMemoryError.

Conclusione

Sulla base dei fatti sopra menzionati, di seguito sono riportati i possibili scenari in cui è necessario utilizzare gli iteratori.

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