Cómo y dónde usar iteradores

Un objeto de una interfaz de iterador se puede utilizar para recorrer todos los elementos de una colección. Los iteradores se pueden usar para inspeccionar los datos en una colección, pero no se pueden usar para modificar la colección subyacente. En general, para usar un iterador para recorrer el contenido de una colección, se deben seguir los siguientes pasos:

1. Obtenga un iterador al inicio de la colección llamando al método iterador de la colección.
2. Configure un bucle que haga una llamada al método hasNext. Haga que el bucle se repita siempre que el método hasNext devuelva verdadero.
3. Dentro del bucle, obtenga cada elemento llamando al siguiente método.

Las API Aspose.Cells proporcionan un montón de iteradores, sin embargo, este artículo analiza principalmente los tres tipos que se enumeran a continuación.

1. Cells iterador
2. Iterador de filas
3. Iterador de columnas

Cómo usar iteradores

Cells iterador

Hay varias formas de acceder al iterador de celdas, y uno puede usar cualquiera de estos métodos según los requisitos de la aplicación. Estos son los métodos que devuelven el iterador de las celdas.

1. Cells.iterator
2. Fila.iterador
3. Rango.iterador

Todos los métodos mencionados anteriormente devuelven el iterador que permite recorrer la colección de celdas que se han inicializado.

Al atravesar las celdas, la colección no debe modificarse (operaciones que harán que se cree una instancia de un nuevo Cell o que se elimine un Cell existente). De lo contrario, es posible que el iterador no pueda recorrer todas las celdas correctamente (algunos elementos pueden recorrerse repetidamente u omitirse).

El siguiente ejemplo de código demuestra la implementación de la clase Iterator para una colección de celdas.

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

Iterador de filas

Se puede acceder al iterador de filas mientras se usa el método RowCollection.iterator. El siguiente ejemplo de código muestra la implementación de la clase Iterator for 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());
}

Iterador de columnas

Se puede acceder al iterador de columnas mientras se usa el método ColumnCollection.iterator. El siguiente ejemplo de código muestra la implementación de la clase Iterator for 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());
}

Dónde usar iteradores

Para discutir las ventajas de usar iteradores, tomemos un ejemplo en tiempo real.

Guión

Un requisito de la aplicación es recorrer todas las celdas de una hoja de trabajo determinada para leer sus valores. Podría haber varias formas de implementar este objetivo. Algunos se muestran a continuación.

Uso del rango de visualización

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

Uso de MaxDataRow y 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());
	}
}

Como puede observar, los dos enfoques mencionados anteriormente utilizan una lógica más o menos similar, es decir; recorra todas las celdas de la colección para leer los valores de las celdas. Esto podría ser problemático por varias razones, como se analiza a continuación.

1. Las API como MaxRow, MaxDataRow, MaxColumn, MaxDataColumn y MaxDisplayRange requieren más tiempo para recopilar las estadísticas correspondientes. En caso de que la matriz de datos (filas x columnas) sea grande, el uso de estas API podría penalizar el rendimiento.
2. En la mayoría de los casos, no se instancian todas las celdas en un rango dado. En tales situaciones, verificar cada celda de la matriz no es tan eficiente en comparación con verificar solo las celdas inicializadas.
3. Acceder a una celda en un bucle como Cells.get(rowIndex, columnIndex) hará que se creen instancias de todos los objetos de celda en un rango, lo que eventualmente puede causar OutOfMemoryError.

Conclusión

Con base en los hechos mencionados anteriormente, a continuación se muestran los posibles escenarios en los que se deben usar los iteradores.

1. Se requiere acceso de solo lectura de la colección de celdas, es decir; El requisito es solo inspeccionar las celdas.
2. Se va a atravesar un gran número de celdas.
3. Solo se deben recorrer las celdas/filas/columnas inicializadas.