Patrón de Diseño ITERADOR
Proposito
El patrón Iterador es un mecanismo de acceso a los elementos que constituyen una estructura de datos para la utilización de estos sin exponer su estructura interna.
El patrón Iterador es un mecanismo de acceso a los elementos que constituyen una estructura de datos para la utilización de estos sin exponer su estructura interna.
Motivación
El patrón surge del deseo de acceder a los elementos de un contenedor de
objetos (por ejemplo, una lista) sin exponer su representación interna. Además,
es posible que se necesite más de una forma de recorrer la estructura siendo
para ello necesario crear modificaciones en la clase.
La solución que propone el patrón es añadir métodos que permitan recorrer la
estructura sin referenciar explícitamente su representación. La responsabilidad
del recorrido se traslada a un objeto iterador.
El problema de introducir este objeto iterador reside en que los clientes necesitan conocer la estructura para crear el iterador apropiado.
Esto se soluciona generalizando los distintos iteradores en una abstracción y dotando a las estructuras de datos de un método
de fabricación que cree un iterador concreto.
Aplicabilidad
El patrón iterator permite el acceso al contenido de una estructura
sin exponer su representación interna. Además diferentes iteradores pueden presentar diferentes tipos de recorrido
sobre la estructura (recorrido de principio a fin, recorrido con saltos...).
Por otro lado los iteradores no tienen por qué limitarse a
recorrer la estructura, sino que podrían incorporar otro tipo de lógica (por
ejemplo, filtrado de elementos). Es más, dados diferentes tipos de estructuras,
el patrón iterador permite recorrerlas todas utilizando una interfaz
común uniforme
Consecuencias
El patrón Iterador permite por tanto diferentes tipos de recorrido de
un agregado y varios recorridos simultáneos, simplificando la interfaz del
agregado.
Estructura
Fuente Wikipedia
Explicación Simple:
El objetivo principal de este patrón es la manipulación de datos mediante los indices de una estructura ya sea estática (Arrays) o dinámica (Listas). la condición de este patrón es que el acceso debe de ser secuencial mente, a continuación se mencionan algunas de las operaciones que puede contener una clase iterador:
-Recorridos uno a uno hacia delante.
-Recorridos uno a uno hacia atras.
-Recorridos en saltos.
-Aplicación de Filtros.
-Aplicación de operaciones.
-Consulta de un dato por su posición.
-etc..
Lo que no se puede hacer:
X-Ordenaciones.(ya que requiere de un recorrido unico de principio a fin las veces que tenga como talla.).
El principal problema que viene a resolver este patron es lo siguiente.
Suponemos que tenemos una clase con un vector de tipo (int) la cual queremos saber cuantos de ellos son pares. estaría de esta manera:
La forma simple de saber cuales son pares seria de manera sencilla y sin patron , un metodo que imprimiera los pares.
public class VectorDatos{
int[] datos = new int[5];
public VectorDatos(){
//llenamos el vector con los 5 datos
datos[0] = 10;
datos[1] = 3;
datos[2] = 6;
datos[3] = 5;
datos[4] = 1;
}
public void filtrarPares()
{
for(int i=0;i<5;i++)
{
if(getValor(i) / 2 ==0)
{
imprimirPosicion(i);
}
}
}
public void imprimirPosicion(int pos)
{
System.out.printf("Valor : "+getValor(pos) .toString());
}
public int getValor(int pos){
return datos[pos];
}
public void setValor(int pos, int valor){
datos[pos] = valor;
}
public int dimension(){
return _datos.length;
}
return datos[pos];
}
public void setValor(int pos, int valor){
datos[pos] = valor;
}
public int dimension(){
return _datos.length;
}
}
ahora si quisiera saber cuales son los impares, la solucion seria hacer otro metodo y anexarlos a la clase quedaria asi:
public class VectorDatos{
int[] datos = new int[5];
public VectorDatos(){
//llenamos el vector con los 5 datos
datos[0] = 10;
datos[1] = 3;
datos[2] = 6;
datos[3] = 5;
datos[4] = 1;
}
public void filtrarPares()
{
for(int i=0;i<5;i++)
{
if(getValor(i) / 2 ==0)
{
imprimirPosicion(i);
}
}
}
public void filtrarImpares()
{
for(int i=0;i<5;i++)
{
if(getValor(i) / 2 !=0)
{
imprimirPosicion(i);
}
}
}
public void imprimirPosicion(int pos)
{
System.out.printf("Valor : "+getValor(pos) .toString());
}
public int getValor(int pos){
return datos[pos];
}
public void setValor(int pos, int valor){
datos[pos] = valor;
}
public int dimension(){
return _datos.length;
}
return datos[pos];
}
public void setValor(int pos, int valor){
datos[pos] = valor;
}
public int dimension(){
return _datos.length;
}
}
y si quisiera anexarle otro metodo que me filtrara a los ceros, seguiria siendo la misma solucion crear un metodo y anexarlo esto convertiria a la clase con una codificación basta.
Lo que el patrón Iterador propone es crear una clase que realice recorridos independientemente de la clase que manipula los valores de la estructura.
la clase iterador quedaria asi:
public class IteradorParesImpares {
private int[] _vector;
private int _posicion;
public IteradorVector(VectorDatos vector) {
_vector = vector._datos;
_posicion = 0;
}
private int[] _vector;
private int _posicion;
public IteradorVector(VectorDatos vector) {
_vector = vector._datos;
_posicion = 0;
}
public void filtrarPares()
{
for(int i=0;i<5;i++)
{
if(getValor(i) / 2 ==0)
{
imprimirPosicion(i);
}
}
}
public void filtrarImpares()
{
for(int i=0;i<5;i++)
{
if(getValor(i) / 2 !=0)
{
imprimirPosicion(i);
}
}
}
public void imprimirPosicion(int pos)
{
System.out.printf("Valor : "+getValor(pos) .toString());
}
public boolean hasNext(){
if (_posicion < _vector.length)
return true;
else
return false;
}
public Object next(){
int valor = _vector[_posicion];
_posicion++;
return valor;
}
if (_posicion < _vector.length)
return true;
else
return false;
}
public Object next(){
int valor = _vector[_posicion];
_posicion++;
return valor;
}
public int getValor(int pos){
return datos[pos];
}
public void setValor(int pos, int valor){
datos[pos] = valor;
}
}
return datos[pos];
}
public void setValor(int pos, int valor){
datos[pos] = valor;
}
}
y la nueva clase manipulador de datos se le anexaría un método el cual al mandarlo a llamar que retorne un objeto de la clase del iterador deseado.
public class VectorDatos {
public int[] datos;
public int[] datos;
int[] datos = new int[5];
public VectorDatos(){
//llenamos el vector con los 5 datos
datos[0] = 10;
datos[1] = 3;
datos[2] = 6;
datos[3] = 5;
datos[4] = 1;
}public int getValor(int pos){
return _datos[pos];
}
public void setValor(int pos, int valor){
_datos[pos] = valor;
}
public int dimension(){
return _datos.length;
}
//nuevo metodo que manda a llamar al iterador deseado
public IteradorParesImpares iterador(){
return new IteradorVector(this);
}
}
public IteradorParesImpares iterador(){
return new IteradorVector(this);
}
}
y se utilizaria asi :
}
// TODO code application logic here
VectorDatos vector = new VectorDatos();
//Creación
del iterador
IteradorParesImpares iterador = vector.iterador();
//Recorrido con el iterador
while (iterador.hasNext())
System.out.println(iterador.next());
// filtrar pares e impares
iterador.filtrarPares();
iterador.filtrarImpares();
}
Podriamos crear mas iteradores con diferentes funciones y usarlos con la misma estructura, solo tendríamos que crear un nuevo método en la clase manupulador que cree el objeto iterador y se pase el this como parametro.
(Espero les haya servidor, recibo sugerencias y comentarios de cualquier tipo)
