What is Iterator Design Pattern?
Iterator design pattern is used for finding a method to operate the elements in a collection in an orderly approach without any need for knowing its primary representation. Iterator pattern is a type of behavioural pattern and it is the most frequently used design pattern in Java programming.
Iterator Design Pattern Implementation Using Java
Consider an example containing list of movies. Client program requires traversing through the list of movies on the whole or based on the language of the movie. Few client programs might require only English movies and they want to access only English movies by avoiding other languages. In this case, Iterator design pattern can be utilized and iteration can be offered on the basis of language of the movie.
Given below is the complete source code to implement this scenario using Iterator design pattern:
Movie.java
Movie.java is a plain POJO class which includes elements, movieName and language.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public class Movie { private String movieName; private String movieLanguage; public Movie(String movieName, String movieLanguage) { this.movieName = movieName; this.movieLanguage = movieLanguage; } public String getMovieName() { return movieName; } public void setMovieName(String movieName) { this.movieName = movieName; } public String getMovieLanguage() { return movieLanguage; } public void setMovieLanguage(String movieLanguage) { this.movieLanguage = movieLanguage; } } |
iPlayer.java
iPlayer is the base interface.
|
1 2 3 4 5 6 7 8 |
import java.util.List; public interface iPlayer { public List<Movie> getMovies(); public void addMovie(Movie movie); public void removeMovie(Movie movie); public iIterator createIterator(String iteratorType); } |
PlayerImpl.java
Next step is to implement the Iterator.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import java.util.ArrayList; import java.util.List; public class PlayerImpl implements iPlayer { List<Movie> movieList; public PlayerImpl() { movieList = new ArrayList<Movie>(); } @Override public List<Movie> getMovies() { return movieList; } @Override public void addMovie(Movie movie) { movieList.add(movie); } @Override public void removeMovie(Movie movie) { movieList.remove(movie); } @Override public iIterator createIterator(String iteratorType) { if ("English".equals(iteratorType)) { return new EnglishIterator(movieList); } else { return new GermanIterator(movieList); } } } |
Here the iIterator interface is implemented by inner class style of implementation. So this implementation can never be utilized by any other aggregate.
iIterator.java
|
1 2 3 4 5 |
public interface iIterator { public Movie nextMovie (); public boolean isLastMovie(); public Movie currentMovie(); } |
EnglishIterator.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
import java.util.List; public class EnglishIterator implements iIterator{ private List<Movie> movieList; private int position; public EnglishIterator(List<Movie> movieList) { this.movieList = movieList; } @Override public Movie nextMovie() { Movie movie = null; for (; position < movieList.size(); position++) { if ("English".equals(movieList.get(position).getMovieLanguage())) { movie = movieList.get(position); position++; break; } } return movie; } @Override public boolean isLastMovie() { for (int i = position; i < movieList.size(); i++) { if ("English".equals((movieList.get(i)).getMovieLanguage())) { return false; } } return true; } @Override public Movie currentMovie() { if (position < movieList.size()) { return movieList.get(position); } return null; } } |
GermanIterator.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
import java.util.List; public class GermanIterator implements iIterator { List<Movie> movieList; private int position; public GermanIterator(List<Movie> movieList) { this.movieList = movieList; } @Override public Movie nextMovie() { Movie movie = null; for (; position < movieList.size(); position++) { if ("German".equals((movieList.get(position)).getMovieLanguage())) { movie = movieList.get(position); position++; break; } } return movie; } @Override public boolean isLastMovie() { for (int i = position; i < movieList.size(); i++) { if ("German".equals((movieList.get(i)).getMovieLanguage())) { return false; } } return true; } @Override public Movie currentMovie() { if (position < movieList.size()) { return movieList.get(position); } return null; } } |
IteratorCheck.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
public class IteratorCheck { public static void main(String args[]) { PlayerImpl player = new PlayerImpl(); player.addMovie(new Movie("Father", "English")); player.addMovie(new Movie("Mummy", "English")); player.addMovie(new Movie("Vater", "German")); player.addMovie(new Movie("Godfather", "English")); player.addMovie(new Movie("Wilder Stier", "German")); iIterator englishIterator = player.createIterator("English"); while (!englishIterator.isLastMovie()) { System.out.println("English Movie: " + englishIterator.nextMovie().getMovieName()); } iIterator germanIterator = player.createIterator("German"); while (!germanIterator.isLastMovie()) { System.out.println("German Movie: " + germanIterator.nextMovie().getMovieName()); } } } |
Output will be:
English Movie: Father
English Movie: Mummy
English Movie: Godfather
German Movie: Vater
German Movie: Wilder Stier
Leave a Reply