diff --git a/Iterator Design Pattern class diagram.jpeg b/Iterator Design Pattern class diagram.jpeg
new file mode 100644
index 0000000..daf53ba
Binary files /dev/null and b/Iterator Design Pattern class diagram.jpeg differ
diff --git a/Iterator pattern sequence diagram.png b/Iterator pattern sequence diagram.png
new file mode 100644
index 0000000..9b45189
Binary files /dev/null and b/Iterator pattern sequence diagram.png differ
diff --git a/README.md b/README.md
index 9e0034c..daba1d9 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,31 @@
-# DesignPatternsJava9
-This repo consists Gang of Four Design patterns code on Java 9. Each branch in the repository has code of 1 design pattern. Switch repository to try out different design patterns.
+# What is Iterator Design Pattern
+Iterator Design Pattern enables to get a way to access the elements of a collection object in sequential manner without any need to know its underlying representation.
+
+## Diagram
+
+
+
+
+### When to use Iterator Design Pattern
+* When there is a need to take the responsibility for access and traversal out of the aggregate / collection object and define a standard traversal protocol.
+* Iterator pattern is widely used in Java Collection Framework.
+
+### Learn Design Patterns with Java by Aseem Jain
+This repository contains working project code used in video Course by Packt Publication with title "Learn Design Patterns with Java " authored by "Aseem Jain".
+
+### Course link:
+https://www.packtpub.com/application-development/learn-design-patterns-java-9-video
+
+###  Profile: http://in.linkedin.com/in/premaseem
+
+### Authors blog on design patterns:
+https://premaseem.wordpress.com/category/computers/design-patterns/
+
+### Software Design pattern community face book page:
+https://www.facebook.com/DesignPatternGuru/
+
+### Note:
+* This code base will work on Java 9 and above versions.
+* `diagrams` folders carry UML diagrams.
+* `pattern` folder has code of primary example.
+* `patternBonus` folder has code of secondary or bonus example.
diff --git a/diagrams/Iterator Design Pattern class diagram.jpeg b/diagrams/Iterator Design Pattern class diagram.jpeg
new file mode 100644
index 0000000..daf53ba
Binary files /dev/null and b/diagrams/Iterator Design Pattern class diagram.jpeg differ
diff --git a/diagrams/IteratorPatternSequenceDiagram.png b/diagrams/IteratorPatternSequenceDiagram.png
new file mode 100644
index 0000000..891eec0
Binary files /dev/null and b/diagrams/IteratorPatternSequenceDiagram.png differ
diff --git a/diagrams/facebook.png b/diagrams/facebook.png
new file mode 100644
index 0000000..44fcea5
Binary files /dev/null and b/diagrams/facebook.png differ
diff --git a/diagrams/facebooklist.png b/diagrams/facebooklist.png
new file mode 100644
index 0000000..37f8733
Binary files /dev/null and b/diagrams/facebooklist.png differ
diff --git a/pattern/src/com/premaseem/Client.java b/pattern/src/com/premaseem/Client.java
index 15f05df..3f60e29 100644
--- a/pattern/src/com/premaseem/Client.java
+++ b/pattern/src/com/premaseem/Client.java
@@ -4,10 +4,57 @@
@author: Aseem Jain
@title: Design Patterns with Java 9
@link: https://premaseem.wordpress.com/category/computers/design-patterns/
-@copyright: 2018 Packt Publication
*/
public class Client {
public static void main (String[] args) {
- System.out.println("Singleton cook example ");
+ System.out.println("Iterator Pattern BEFORE CODE");
+
+ FaceBook faceBook = new FaceBook();
+ Iterator faceBookIterator = faceBook.getIterator();
+
+ // Loop over
+ // init data with first(), keep increment with next()
+ // and check termination condition with hasNext()
+ for(faceBookIterator.first();faceBookIterator.hasNext();faceBookIterator.next()){
+ System.out.println(faceBookIterator.currentValue());
+ }
+
+ // $$$ Lesson Learned $$$
+ // Loose coupling no need to know or import data structure
+ // Data cannot be compromised ;-)
+ // Provides limited control over data access
+
+
+
+ /* OLD CODE
+ // Data structure is exposed
+ List<String> friendsList = faceBook.getFriendsList();
+
+ // print friends with normal conventional loop
+ for (int i = 0; i < friendsList.size(); i++) {
+ System.out.println(friendsList.get(i));
+ }
+
+ // Un intentional addition of data
+ friendsList.add("Lady gaga");
+
+ // print friends with normal conventional loop
+ for (int i = 0; i < friendsList.size(); i++) {
+ System.out.println(friendsList.get(i));
+ }
+
+ // Clients can accidentally or maliciously trash data structure.
+ friendsList.clear();
+
+ // print friends with normal conventional loop
+ for (int i = 0; i < friendsList.size(); i++) {
+ System.out.println(friendsList.get(i));
+ }
+*/
+ // Lesson Learned
+ // 1. Underlying Data structure is exposed
+ // 2. Data can be manipulated
+ // 3. Data can be get trashed accidentally
+ // 4. Data traversal is not easy or uniform
}
}
diff --git a/pattern/src/com/premaseem/FaceBook.java b/pattern/src/com/premaseem/FaceBook.java
new file mode 100644
index 0000000..1478765
--- /dev/null
+++ b/pattern/src/com/premaseem/FaceBook.java
@@ -0,0 +1,62 @@
+package com.premaseem;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/*
+@author: Aseem Jain
+@title: Design Patterns with Java 9
+@link: https://premaseem.wordpress.com/category/computers/design-patterns/
+*/
+public class FaceBook {
+
+ List<String> friendsList = new ArrayList<>();
+
+ public FaceBook () {
+ // initialize with seed data
+ friendsList.add("Aseem Jain");
+ friendsList.add("James Bond");
+ friendsList.add("Spider Man");
+ friendsList.add("Super Man");
+ }
+
+// public List<String> getFriendsList () {
+// return friendsList;
+// }
+
+ public Iterator getIterator() {
+ return new Iterator(this);
+ }
+}
+
+class Iterator {
+ private FaceBook faceBook;
+ private java.util.Iterator iterator;
+ private String value;
+
+ public Iterator(FaceBook faceBook) {
+ this.faceBook = faceBook;
+ }
+
+ public void first() {
+ iterator = faceBook.friendsList.iterator();
+ next();
+ }
+
+ public void next() {
+ try {
+ value = (String)iterator.next();
+ } catch (NoSuchElementException ex) {
+ value = null;
+ }
+ }
+
+ public boolean hasNext() {
+ return value != null;
+ }
+
+ public String currentValue() {
+ return value;
+ }
+}
\ No newline at end of file
diff --git a/patternBonus/src/com/premaseem/Client.java b/patternBonus/src/com/premaseem/Client.java
deleted file mode 100644
index 15f05df..0000000
--- a/patternBonus/src/com/premaseem/Client.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package com.premaseem;
-
-/*
-@author: Aseem Jain
-@title: Design Patterns with Java 9
-@link: https://premaseem.wordpress.com/category/computers/design-patterns/
-@copyright: 2018 Packt Publication
-*/
-public class Client {
- public static void main (String[] args) {
- System.out.println("Singleton cook example ");
- }
-}
diff --git a/patternBonus/src/com/premaseem/iterator/ClientForEmployeeIterator.java b/patternBonus/src/com/premaseem/iterator/ClientForEmployeeIterator.java
new file mode 100644
index 0000000..6e56d5f
--- /dev/null
+++ b/patternBonus/src/com/premaseem/iterator/ClientForEmployeeIterator.java
@@ -0,0 +1,59 @@
+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 employee list using iterators. " +
+ "The data structure details are abstracted behind the iterator interface ");
+
+ employeeManager.addEmployee(new Employee("name1", "M"));
+ employeeManager.addEmployee(new Employee("name2", "f"));
+ employeeManager.addEmployee(new Employee("name3", "M"));
+ employeeManager.addEmployee(new Employee("name4", "Mf"));
+ employeeManager.addEmployee(new Employee("name5", "f"));
+ employeeManager.addEmployee(new Employee("name6", "f"));
+ employeeManager.addEmployee(new Employee("name7", "fM"));
+ employeeManager.addEmployee(new Employee("name8", "m"));
+ employeeManager.addEmployee(new Employee("name9", "m"));
+ employeeManager.addEmployee(new Employee("name10", "f"));
+
+ employeeManager.employeeMap.put(1,new Employee("name1", "M"));
+ employeeManager.employeeMap.put(2,new Employee("name2", "F"));
+ employeeManager.employeeMap.put(3,new Employee("name3", "M"));
+ employeeManager.employeeMap.put(1,new Employee("name4", "F"));
+
+ MaleEmployeeIterator maleEmployeeIterator = employeeManager.getMaleEmployeeIterator();
+ printEmployeeList(maleEmployeeIterator);
+
+ FeMaleEmployeeIterator 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());
+ }
+ }
+
+}
diff --git a/patternBonus/src/com/premaseem/iterator/Employee.java b/patternBonus/src/com/premaseem/iterator/Employee.java
new file mode 100644
index 0000000..c0fe48e
--- /dev/null
+++ b/patternBonus/src/com/premaseem/iterator/Employee.java
@@ -0,0 +1,25 @@
+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 ;
+ }
+}
diff --git a/patternBonus/src/com/premaseem/iterator/EmployeeManger.java b/patternBonus/src/com/premaseem/iterator/EmployeeManger.java
new file mode 100644
index 0000000..de3937c
--- /dev/null
+++ b/patternBonus/src/com/premaseem/iterator/EmployeeManger.java
@@ -0,0 +1,43 @@
+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> employeelist = new ArrayList<Employee>();
+ Map<Integer, Employee> employeeMap = new HashMap<Integer, Employee>();
+
+ void addEmployee(Employee emp) {
+ employeelist.add(emp);
+ }
+
+ boolean removeEmployee(Employee emp) {
+ return employeelist.remove(emp);
+ }
+
+ MaleEmployeeIterator getMaleEmployeeIterator() {
+ return new MaleEmployeeIterator(employeelist);
+ }
+
+ FeMaleEmployeeIterator getFeMaleEmployeeIterator() {
+ return new FeMaleEmployeeIterator(employeelist);
+ }
+
+ Iterator<Employee> getAllEmployeeIterator() {
+ return employeelist.iterator();
+ }
+
+ public Iterator<Entry<Integer, Employee>> printEmployeeMap() {
+ return employeeMap.entrySet().iterator();
+ }
+
+ void calculateEmpSalary() {
+
+ }
+
+}
diff --git a/patternBonus/src/com/premaseem/iterator/MaleEmployeeIterator.java b/patternBonus/src/com/premaseem/iterator/MaleEmployeeIterator.java
new file mode 100644
index 0000000..566b932
--- /dev/null
+++ b/patternBonus/src/com/premaseem/iterator/MaleEmployeeIterator.java
@@ -0,0 +1,68 @@
+package com.premaseem.iterator;
+
+import java.util.Iterator;
+import java.util.List;
+
+public class MaleEmployeeIterator implements Iterator<Employee> {
+
+ private List<Employee> employeelist;
+ private int position;
+ public MaleEmployeeIterator (List<Employee> employeelist){
+ this.employeelist = employeelist;
+ }
+
+ @Override
+ public boolean hasNext() {
+ for (; position < employeelist.size(); position++) {
+ if ("m".equalsIgnoreCase ((employeelist.get(position)).getSex())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public Employee next() {
+ Employee employee = employeelist.get(position);
+ position++;
+ return employee;
+ }
+
+ @Override
+ public void remove() {
+ employeelist.iterator().remove();
+ }
+}
+
+ class FeMaleEmployeeIterator implements Iterator<Employee> {
+
+ private List<Employee> employeelist;
+ private int position;
+ public FeMaleEmployeeIterator (List<Employee> employeelist){
+ this.employeelist = employeelist;
+ }
+
+ @Override
+ public boolean hasNext() {
+ for (; position < employeelist.size(); position++) {
+ if ("f".equalsIgnoreCase ((employeelist.get(position)).getSex())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public Employee next() {
+ Employee employee = employeelist.get(position);
+ position++;
+ return employee;
+ }
+
+ @Override
+ public void remove() {
+ employeelist.iterator().remove();
+ }
+}
+
+
diff --git a/patternBonus/src/com/premaseem/iterator/PatternDescription.txt b/patternBonus/src/com/premaseem/iterator/PatternDescription.txt
new file mode 100644
index 0000000..cce7626
--- /dev/null
+++ b/patternBonus/src/com/premaseem/iterator/PatternDescription.txt
@@ -0,0 +1,31 @@
+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.
\ No newline at end of file