Adjust NestedIterator to support ignored test-case

Use updated RecursiveIterator solution for that

Author: andrei-punko

src/main/java/by/andd3dfx/iterators/NestedIterator.java

@@ -42,43 +42,57 @@
 public class NestedIterator implements Iterator<Integer> {
 
     private final Deque<Iterator<INestedInteger>> stack = new ArrayDeque<>();
+    private Integer nextElement;
 
     public NestedIterator(List<INestedInteger> nestedList) {
         stack.push(nestedList.iterator());
     }
 
     @Override
     public Integer next() {
-        if (stack.isEmpty()) {
+        var result = determineNextElement();
+        if (result == null) {
             throw new NoSuchElementException();
         }
+        return result;
+    }
 
-        var currentIterator = stack.peek();
-        if (!currentIterator.hasNext()) {
-            stack.pop();
-            return next();
+    @Override
+    public boolean hasNext() {
+        if (nextElement != null) {
+            return true;
         }
+        nextElement = determineNextElement();
+        return nextElement != null;
+    }
 
-        INestedInteger object = currentIterator.next();
-        if (object.isInteger()) {
-            return object.getInteger();
+    private Integer determineNextElement() {
+        if (nextElement != null) {
+            var result = nextElement;
+            nextElement = null;
+            return result;
         }
-        stack.push(object.getList().iterator());
-        return next();
-    }
 
-    @Override
-    public boolean hasNext() {
         if (stack.isEmpty()) {
-            return false;
+            return null;
         }
 
-        var currentIterator = stack.peek();
-        if (currentIterator.hasNext()) {
-            return true;
+        while (!stack.isEmpty()) {
+            Iterator<INestedInteger> iterator = stack.peek();
+            if (iterator.hasNext()) {
+                var next = iterator.next();
+
+                if (!next.isInteger()) {
+                    stack.push(next.getList().iterator());
+                    return determineNextElement();
+                } else {
+                    return next.getInteger();
+                }
+            } else {
+                stack.pop();
+            }
         }
-        stack.pop();
-        return hasNext();
+        return null;
     }
 
     public interface INestedInteger {

src/test/java/by/andd3dfx/iterators/NestedIteratorTest.java

@@ -25,11 +25,10 @@ public void testNextAndHasNext() {
             ),
             List.of(1, 4, 6));
 
-        // TODO: fix implementation to support this case
-        // check(List.of(
-        //     new NestedIntegerList()
-        //     ),
-        //     List.of());
+        check(List.of(
+                new NestedIntegerList()
+            ),
+            List.of());
     }
 
     private void check(List<INestedInteger> incoming, List<Integer> outgoing) {