Iterator Pattern

The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying
representation.

It also places the task of traversal on the iterator object, not on the aggregate, which simplifies the aggregate interface and implementation, and places the responsibility where it should be.

Example
public interface Menu {
 public Iterator createIterator();
}
==========
public class MenuItem {
 private String name;
 private String description;
 private boolean vegetarian;
 private double price;
 
 public MenuItem(String name, String desc, boolean vegetarian, double price){
  this.name = name;
  this.description = desc;
  this.vegetarian = vegetarian;
  this.price = price;
 }

  public String getName() {
  return name;
 }

  public String getDescription() {
  return description;
 }

  public boolean isVegetarian() {
  return vegetarian;
 }

  public double getPrice() {
  return price;
 }

  @Override
 public String toString() {
  return "MenuItem [name=" + name + ", description=" + description
    + ", vegetarian=" + vegetarian + ", price=" + price + "]";
 }
}
==========
public class BreakFastMenu implements Menu{
 private HashMap<String,MenuItem> breakFastMenuMap;
 BreakFastMenu(){
  breakFastMenuMap =  new HashMap<String,MenuItem>();
  addMenuItem("boiled_eggs","Boiled eggs and banana only",false,100);
  addMenuItem("juice","Mix fruit juice",true,40);
  addMenuItem("Salads and Curd","Salad and pure curd",true,70);
 }
 
 public void addMenuItem(String name, String description, boolean vegeratian, double price){
  MenuItem menuItem = new MenuItem(name, description, vegeratian, price);
  breakFastMenuMap.put(name, menuItem);
 }
 
 @Override
 public Iterator<MenuItem> createIterator() {
  return breakFastMenuMap.values().iterator();
 }
}
==========
import java.util.ArrayList;
import java.util.Iterator;
public class DinnerMenu implements Menu{
 private ArrayList<MenuItem> arrayList;
 DinnerMenu(){
  arrayList = new ArrayList<MenuItem>(10);
  addMenuItem("rotisabji", "Luch contains roti and subji and some curd", true, 40);
  addMenuItem("milk and roti", "Luch contains milk and roti only", true, 50);
  addMenuItem("chicken and rice", "Luch contains chicke and rince only", true, 50);
  addMenuItem("pau bhaji", "Luch pau bhaji and roasted papad", true, 60);
 }
 
 public void addMenuItem(String name, String description, boolean vegeratian, double price){
   MenuItem menuItem = new MenuItem(name, description, vegeratian, price);
   arrayList.add(menuItem);
 }
 
 public Iterator<MenuItem> createIterator(){
  return arrayList.iterator();
 }
}
==========
import java.util.Iterator;
public class LunchMenu implements Menu{
 private final int MAX_LUNCH_MENU_TEMS = 10;
 private MenuItem array[] ;
 private int availableTotalMenuItems = 0;
 
 LunchMenu(){
  array = new MenuItem[10];
  
  addMenuItem("rotisabji", "Luch contains roti and subji and some curd", true, 40);
  addMenuItem("milk and roti", "Luch contains milk and roti only", true, 50);
  addMenuItem("chicken and rice", "Luch contains chicke and rince only", true, 50);
  addMenuItem("pau bhaji", "Luch pau bhaji and roasted papad", true, 60);
 }
 
 public void addMenuItem(String name, String description, boolean vegeratian, double price){
  if(availableTotalMenuItems==MAX_LUNCH_MENU_TEMS){
   System.out.println("Menu is full. Maximul item in menu can be 10.");
  }else{
   MenuItem menuItem = new MenuItem(name, description, vegeratian, price);
   array[availableTotalMenuItems] = menuItem;
   availableTotalMenuItems++;
  }
 }

  public Iterator<MenuItem> createIterator(){
  LunchIterator iterator = new LunchIterator(array);
  return iterator;
 }
}
==========
import java.util.Iterator;
public class LunchIterator implements Iterator<MenuItem>{
 private MenuItem[] menuArray;
 private int index = 0;
 public LunchIterator(MenuItem[] arrayList){
  this.menuArray = arrayList;
 }
 
 @Override
 public boolean hasNext() {
  if(index>=menuArray.length || menuArray[index]==null){
   return false;
  }else{
   return true;
  }
 }

  @Override
 public MenuItem next() {
  MenuItem item = menuArray[index];
  index = index + 1;
  return item;
 }
}
==========
import java.util.Iterator;
public class Waitress {
 private Menu dinner;
 private Menu lunch;
 private Menu breakfast;
 
 public Waitress(Menu breakfast, Menu lunch,Menu dinner){
  this.breakfast =  breakfast;
  this.dinner = dinner;
  this.lunch = lunch;
 }
 
 public void printMenu(){
  System.out.println("MENU\n====");
  System.out.println("\nBREAKFAST\n========");
  Iterator breakfastIterator = breakfast.createIterator();
  printMenu(breakfastIterator);
  
  System.out.println("\nLUNCH\n====");
  Iterator lunchIterator = lunch.createIterator();
  printMenu(lunchIterator);
  
  System.out.println("\nDINNER\n=====");
  Iterator dinnerIterator = dinner.createIterator();
  printMenu(dinnerIterator);
 }
 
 private void printMenu(Iterator<MenuItem> iterator){
  while(iterator.hasNext()){
   MenuItem menuItem = (MenuItem)iterator.next();
   System.out.println(menuItem);
  }  
 }
}
==========
import java.util.Iterator;
public class LunchIterator implements Iterator<MenuItem>{
 private MenuItem[] menuArray;
 private int index = 0;
 public LunchIterator(MenuItem[] arrayList){
  this.menuArray = arrayList;
 }
 
 @Override
 public boolean hasNext() {
  if(index>=menuArray.length || menuArray[index]==null){
   return false;
  }else{
   return true;
  }
 }

  @Override
 public MenuItem next() {
  MenuItem item = menuArray[index];
  index = index + 1;
  return item;
 }
}
==========
public class IteratorFlight {
 public static void main(String[] universe){
  BreakFastMenu breakfast = new BreakFastMenu();
  LunchMenu lunch = new LunchMenu();
  DinnerMenu dinner = new DinnerMenu();
  Waitress waitress = new Waitress(breakfast, lunch, dinner);
  waitress.printMenu();
 }

}