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 utilizar para inspeccionar los datos en una colección, pero no se pueden utilizar 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. Obtener un iterador al comienzo de la colección llamando al método iterador de la colección.
2. Configurar un bucle que haga una llamada al método hasNext. Hacer que el bucle itere siempre que el método hasNext devuelva true.
3. Dentro del bucle, obtener cada elemento llamando al método next.

Aspose.Cells APIs proporciona una variedad de iteradores, sin embargo, este artículo principalmente discute los tres tipos enumerados a continuación.

1. Iterador de Celdas
2. Iterador de Filas
3. Iterador de Columnas

Cómo usar Iteradores

Iterador de Celdas

Existen varias formas de acceder al iterador de celdas, y se puede usar cualquiera de estos métodos según los requisitos de la aplicación. Aquí están los métodos que devuelven el iterador de celdas.

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

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

Durante el recorrido de las celdas, la colección no debe ser modificada (operaciones que provocarán que se instancie una nueva Celda o que se elimine una Celda existente). De lo contrario, el iterador puede no ser capaz de recorrer todas las celdas correctamente (algunos elementos pueden ser recorridos repetidamente o saltados).

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

El Iterador de Filas se puede acceder al usar el método RowCollection.iterator. El siguiente ejemplo de código demuestra la implementación del Iterador para la clase 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

El Iterador de Columnas se puede acceder al usar el método ColumnCollection.iterator. El siguiente ejemplo de código demuestra la implementación del Iterador para la clase 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, veamos un ejemplo en tiempo real.

Escenario

Un requisito de la aplicación es recorrer todas las celdas en una Hoja de Cálculo dada para leer sus valores. Podrían haber varias formas de implementar este objetivo. Algunas se muestran a continuación.

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

Usando 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 puedes observar, ambos enfoques mencionados anteriormente utilizan una lógica más o menos similar, es decir; recorrer todas las celdas en la colección para leer los valores de las celdas. Esto podría ser problemático por varias razones, como se discute a continuación.

1. Las APIs como MaxRow, MaxDataRow, MaxColumn, MaxDataColumn y MaxDisplayRange requieren tiempo adicional para recopilar las estadísticas correspondientes. En caso de que la matriz de datos (filas x columnas) sea grande, usar estas APIs podría imponer una penalización en el rendimiento.
2. En la mayoría de los casos, no todas las celdas en un rango dado están instanciadas. En tales situaciones, verificar cada celda en 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(filaIndice, columnaIndice) hará que se instancien todos los objetos de celda en un rango, lo que eventualmente puede causar un OutOfMemoryError.

Conclusión

Basándose en los hechos mencionados anteriormente, a continuación se presentan los posibles escenarios donde deberían usarse los iteradores.

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