Added solution and a better test

Task_A/src/Enumerable.java

-
-
 import java.util.Collection;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Iterator;
 
 public class Enumerable<T> implements Iterable<T> {
 
-	private Iterator<T> iterator;
+	private List<IPredicate<T>> predicates;
+	private Collection<T> collection;
 
 	public Enumerable(Collection<T> collection) {
-		this.iterator = collection.iterator();
-	}
-
-	Enumerable<T> where(IPredicate<T> predicate) {
-		Iterator<T> oldIterator = iterator;
-		this.iterator = new Iterator<T>() {
-
-			@Override
-			public boolean hasNext() {
-				return oldIterator.hasNext();
-			}
-
-			@Override
-			public T next() {
-				T item = oldIterator.hasNext() ? oldIterator.next() : null;
-				while (oldIterator.hasNext() && !predicate.accept(item)) {
-					item = oldIterator.next();
-				}
-				return item;
-			}
-		};
-		return this;
+		this.collection = collection;
+		this.predicates = new ArrayList<IPredicate<T>>();
+	}	
+
+	public Enumerable(Collection<T> collection, List<IPredicate<T>> predicates) {
+		this.collection = collection;
+		this.predicates = predicates;
+	}	
+
+	public Enumerable<T> where(IPredicate<T> predicate) {
+		List<IPredicate<T>> newPredicates = new ArrayList<IPredicate<T>>(predicates);
+		newPredicates.add(predicate);
+		return new Enumerable<T>(collection, newPredicates);
 	}
 
 	@Override
 	public Iterator<T> iterator() {
-		return iterator;
+		return new EnumerableIterator<T>(collection, predicates);
 	}
 
-	void forEach(IAction<T> action) {
+	public void forEach(IAction<T> action) {
+		Iterator<T> iterator = iterator();
 		while (iterator.hasNext()) {
 			T t = (T) iterator.next();
 			action.perform(t);
@@ -45,3 +38,4 @@ public class Enumerable<T> implements Iterable<T> {
 	}
 
 }
+

Task_A/src/EnumerableIterator.java

+import java.util.List;
+import java.util.Iterator;
+import java.util.Collection;
+
+public class EnumerableIterator<T> implements Iterator<T> {
+	
+	private Iterator<T> collectionIterator;
+	public T peaked;
+	private List<IPredicate<T>> predicates;
+
+	public EnumerableIterator(Collection<T> collection, List<IPredicate<T>> predicates) {
+		this.collectionIterator = collection.iterator();
+		this.predicates = predicates;
+	}
+
+	@Override
+	public boolean hasNext() {
+		if (peaked == null && collectionIterator.hasNext()) { // peaked is null if not checked
+			while (collectionIterator.hasNext()) {
+				peaked = collectionIterator.next();
+				if (accept(peaked))
+					return true;
+			}
+			peaked = null;
+		}
+		return peaked != null;
+	}
+
+	@Override
+	public T next() {
+		T next = null;
+		if (hasNext()) {
+			next = peaked;
+			peaked = null;
+		}
+		return next;
+	}
+	
+	private boolean accept(T t) {
+		for (IPredicate<T> p : predicates) {
+			if (!p.accept(t))
+				return false;
+		}
+		return true;
+	}
+}

Task_A/src/Test.java

-
-
 import java.text.MessageFormat;
 import java.util.ArrayList;
 
@@ -13,7 +11,26 @@ public class Test {
 		arrayList.add(7);
 
 		Enumerable<Integer> enumerable = new Enumerable<>(arrayList);
-		Enumerable<Integer> evenNumbers = enumerable
+		Enumerable<Integer> enumerablePrimes = enumerable
+		
+				.where(new IPredicate<Integer>() {
+
+			@Override
+			public boolean accept(Integer element) {
+				if (element <= 3)
+					return element > 1;
+				else if (element % 2 == 0 || element % 3 == 0)
+			    	return false;
+			    int i = 5;
+				while (i * i <= element) {
+					if (element % i == 0 || element % (i + 2) == 0)
+						return false;
+			    	i = i + 6;
+				}
+	    	    return true;
+			}
+		});
+		Enumerable<Integer> evenNumbers = enumerablePrimes
 				.where(new IPredicate<Integer>() {
 
 					@Override
@@ -22,7 +39,7 @@ public class Test {
 					}
 				});
 
-		Enumerable<Integer> oddNumbers = enumerable
+		Enumerable<Integer> oddNumbers = enumerablePrimes
 				.where(new IPredicate<Integer>() {
 
 					@Override
@@ -43,7 +60,7 @@ public class Test {
 
 			@Override
 			public void perform(Integer t) {
-				System.out.println(MessageFormat.format("Odd number{0}", t));				
+				System.out.println(MessageFormat.format("Odd number {0}", t));				
 			}
 		});
 	}