Update Enumerable.java

Task_A/src/Enumerable.java

-
-
 import java.util.Collection;
 import java.util.Iterator;
 
 public class Enumerable<T> implements Iterable<T> {
 
+	// Define variables
+
+	private Enumerable<T> newEnumerable;
 	private Iterator<T> iterator;
+	private Collection<T> newCollection;
+
+
+	// Use collection for iteration operations
 
 	public Enumerable(Collection<T> collection) {
+
 		this.iterator = collection.iterator();
+		this.newCollection = collection;
+
 	}
 
+	// Redefined where() method
+
 	Enumerable<T> where(IPredicate<T> predicate) {
-		Iterator<T> oldIterator = iterator;
-		this.iterator = new Iterator<T>() {
+
+		// Need to create a new Enumerable, or else the same reference will be used
+		// and you can only iterate through a given list once
+
+		newEnumerable = new Enumerable<T>(newCollection);
+
+		newEnumerable.iterator = new Iterator<T>() {
+
+			Iterator<T> oldIterator = newEnumerable.iterator;
 
 			@Override
-			public boolean hasNext() {
-				return oldIterator.hasNext();
-			}
+			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();
+
+				// define element as T
+				T element;
+
+				// if iterator has more items, we get it, else return null
+				if(oldIterator.hasNext()) {
+					element = oldIterator.next();
+				} else {
+					element = null;
 				}
-				return item;
+
+				while (oldIterator.hasNext() && !predicate.accept(element)) element = oldIterator.next();
+
+				// handle last element
+				if( !(oldIterator.hasNext() || predicate.accept(element)) ) element = null;
+
+				return element;
 			}
 		};
-		return this;
+
+		// cannot use or return this, else the same list cannot be reused after 1 full iteration
+		return newEnumerable;
+
 	}
 
+
 	@Override
 	public Iterator<T> iterator() {
 		return iterator;
@@ -39,9 +70,14 @@ public class Enumerable<T> implements Iterable<T> {
 
 	void forEach(IAction<T> action) {
 		while (iterator.hasNext()) {
-			T t = (T) iterator.next();
-			action.perform(t);
+
+			// get next element
+			T nextItem = (T) iterator.next();
+
+			// ignore last (null) element
+			if (nextItem != null) action.perform(nextItem);
 		}
 	}
 
+
 }