package com.premaseem.iterator;

import java.util.Iterator;

import java.util.Map.Entry;

public class ClientForEmployeeIterator {

public static void main(String[] args) {

EmployeeManger employeeManager = new EmployeeManger();

System.out

.println("This is Iterator Pattern example where you can list all the male / female emplyee list using iterators. The data structure details are abstraced behind the iterator interface ");

employeeManager.addEmployee(new Employee("aseem1", "M"));

employeeManager.addEmployee(new Employee("Meera1", "f"));

employeeManager.addEmployee(new Employee("aseem2", "M"));

employeeManager.addEmployee(new Employee("sony1", "Mf"));

employeeManager.addEmployee(new Employee("Meera2", "f"));

employeeManager.addEmployee(new Employee("Meera3", "f"));

employeeManager.addEmployee(new Employee("Meeralast", "f"));

employeeManager.addEmployee(new Employee("sony2", "fM"));

employeeManager.addEmployee(new Employee("aseem1", "m"));

employeeManager.addEmployee(new Employee("aseemlast", "m"));

employeeManager.employeeMap.put(1,new Employee("aseem1", "M"));

employeeManager.employeeMap.put(2,new Employee("aseem2", "F"));

employeeManager.employeeMap.put(3,new Employee("aseem3", "M"));

employeeManager.employeeMap.put(1,new Employee("aseem4", "F"));

MaleEmplyeeIterator maleEmployeeIterator = employeeManager.getMaleEmployeeIterator();

printEmployeeList(maleEmployeeIterator);

FeMaleEmplyeeIterator feMaleEmployeeIterator = employeeManager.getFeMaleEmployeeIterator();

printEmployeeList(feMaleEmployeeIterator);

Iterator<Employee> allEmployeeIterator = employeeManager.getAllEmployeeIterator();

printEmployeeList(allEmployeeIterator);

printEmplyeeMap(employeeManager.printEmployeeMap());

}

private static void printEmplyeeMap(Iterator<Entry<Integer, Employee>> iterator) {

System.out.println("Printing employee map ");

while (iterator.hasNext()) {

Entry<Integer, Employee> next = iterator.next();

System.out.println(next);

}

}

private static void printEmployeeList(Iterator iterator) {

System.out.println("Printing the list for " + iterator.getClass().getSimpleName());

while (iterator.hasNext()) {

System.out.println(iterator.next());

}

}

}

package com.premaseem.iterator;

public class Employee {

String name;

String sex;

public Employee(String name, String sex){

this.name = name;

this.sex = sex;

}

public String getName() {

return name;

}

public String getSex() {

return sex;

}

@Override

public String toString() {

return sex + " " + name ;

}

}

package com.premaseem.iterator;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

public class EmployeeManger {

List<Employee> emplyeelist = new ArrayList<Employee>();

Map<Integer, Employee> employeeMap = new HashMap<Integer, Employee>();

void addEmployee(Employee emp) {

emplyeelist.add(emp);

}

boolean removeEmployee(Employee emp) {

return emplyeelist.remove(emp);

}

MaleEmplyeeIterator getMaleEmployeeIterator() {

return new MaleEmplyeeIterator(emplyeelist);

}

FeMaleEmplyeeIterator getFeMaleEmployeeIterator() {

return new FeMaleEmplyeeIterator(emplyeelist);

}

Iterator<Employee> getAllEmployeeIterator() {

return emplyeelist.iterator();

}

public Iterator<Entry<Integer, Employee>> printEmployeeMap() {

return employeeMap.entrySet().iterator();

}

void calculateEmpSalary() {

}

}

package com.premaseem.iterator;

import java.util.Iterator;

import java.util.List;

public class MaleEmplyeeIterator implements Iterator<Employee> {

private List<Employee> emplyeelist;

private int position;

public MaleEmplyeeIterator(List<Employee> emplyeelist){

this.emplyeelist = emplyeelist;

}

@Override

public boolean hasNext() {

for ( ;position < emplyeelist.size(); position++) {

if ("m".equalsIgnoreCase ((emplyeelist.get(position)).getSex())) {

return true;

}

}

return false;

}

@Override

public Employee next() {

Employee employee = emplyeelist.get(position);

position++;

return employee;

}

@Override

public void remove() {

emplyeelist.iterator().remove();

}

}

class FeMaleEmplyeeIterator implements Iterator<Employee> {

private List<Employee> emplyeelist;

private int position;

public FeMaleEmplyeeIterator(List<Employee> emplyeelist){

this.emplyeelist = emplyeelist;

}

@Override

public boolean hasNext() {

for ( ;position < emplyeelist.size(); position++) {

if ("f".equalsIgnoreCase ((emplyeelist.get(position)).getSex())) {

return true;

}

}

return false;

}

@Override

public Employee next() {

Employee employee = emplyeelist.get(position);

position++;

return employee;

}

@Override

public void remove() {

emplyeelist.iterator().remove();

}

}

Intent

Explicitly separate the notion of "algorithm" from that of "data structure".

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

The key idea is to take the responsibility for access and traversal out of the aggregate object and put it into an Iterator object that defines a standard traversal protocol.

Problem solved by pattern

Need to "abstract" the traversal of wildly different data structures so that algorithms can be defined that are capable of interfacing with each transparently.

"An aggregate object such as a list should give you a way to access its elements without exposing its internal structure. Moreover, you might want to traverse the list in different ways, depending on what you need to accomplish. But you probably don't want to bloat the List interface with operations for different traversals, even if you could anticipate the ones you'll require. You might also need to have more than one traversal pending on the same list." And, providing a uniform interface for traversing many types of aggregate objects (i.e. polymorphic iteration) might be valuable.

The Iterator pattern lets you do all this. The key idea is to take the responsibility for access and traversal out of the aggregate object and put it into an Iterator object that defines a standard traversal protocol.

The Iterator abstraction is fundamental to an emerging technology called "generic programming". This strategy seeks to explicitly separate the notion of "algorithm" from that of "data structure". The motivation is to: promote component-based development, boost productivity, and reduce configuration management.

Key Notes on Iterator in Java:

Iterator in Java basically is used to support generics thereby making it mandatory to make use of the Generic version of Iterator and not the Iterator with raw type.

In case the objects need to be removed from the Collection, in that case do not make use of for-each loop. Instead one can make use of Iterator's remove() method to avoid any ConcurrentModificationException.

As far as Iterating over collection with the help of Iterator concerned, it is subject to ConcurrentModificationException if Collection is modified after Iteration started. However this is meant to take place only in case of fail-fast Iterators.

We have fail-fast and fail-safe type of Iterators in Java and you need to check for the difference between these types.

List collection type is also known to supports ListIterator that comprises of add() method so as to incorporate elements in collection at the time of iteration. Difference between Iterator and ListIterator has also been discussed above.

Read more: http://mrbool.com/how-to-create-iterator-in-java/26422#ixzz3DMNSrEMN

External vs Internal Iterator

When the client controls the iteration sequence and index position then it is called as the external iterator. Otherwise if the iterator controls the traversal then it is called internal iterator. On external iterator, the design is that the invoking client code should explicitly invoke the method to move the pointer to next element. For internal iterator, when an element is accessed, after access the pointer will be automatically moved to next index by the iterator. In general internal iterators are easier to use than the external iterators.