CareerCup

Too easy

class FlatIterator implements Iterator {
    Iterator curI;
    LinkedList<Iterator> stack;

    public FlatIterator(Iterator i) {
        curI = i;
        stack = new LinkedList<Iterator>();
    }

    @Override
    public boolean hasNext() {
        if (curI.hasNext()) {
            return true;
        }
        if (!stack.isEmpty()) {
            curI = stack.pop();
            return hasNext();
        } else {
            return false;
        }

    }

    @Override
    public Object next() {
        final Object next = curI.next();
        if (next instanceof Iterator) {
            stack.push(curI);
            curI = (Iterator) next;
            return next();
        } else {
            return next;
        }
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("Not required");
    }
}

package com.anand.learn.iter;

/**
 * @author akeshri
 *
 */
public interface MyIterable<E> {
	
	public MyIterator<E> iterate();

}

package com.anand.learn.iter;

/**
 * @author akeshri
 *
 */
public interface MyIterator<E> {
	
	public boolean hasNext();
	
	public E next();

}

/**
 * 
 */
package com.anand.learn.iter;

import java.util.List;

/**
 * @author akeshri
 * @param <E>
 *
 */
public class MyObject<E> implements MyIterable<E>  {

	/* (non-Javadoc)
	 * @see com.anand.learn.iter.MyIterable#iterate()
	 */
	@Override
	public MyIterator<E> iterate() {
		
		return (MyIterator<E>) new MyIteratorImpl<E>();
	}
	
	class MyIteratorImpl<E> {
		
	}
	
	
	public void loopIter(MyIterator<E> iter) {
		if (iter != null ) {
			while (iter.hasNext()) {
				if(iter.next() instanceof MyIterator){
					//loop over Iterator ot read the object
				} else {
					//print the object
				}
			}
		}
	}

}

What do you mean by "flattens"? Can you explain the question more specifically

package testing;

import java.util.Iterator;
import java.util.List;

public class AddedIteratots {

	private List <Iterator<?>> iteratots;
	private Iterator<?> currentit;
	private int currentItIndex = 0;
	public AddedIteratots(List <Iterator<?>> iteratots){
		this.iteratots = iteratots;
		currentit = iteratots.get(0);
	}
	
	public boolean hasNext(){
		boolean ret = false;
		if(currentit.hasNext())
			ret=currentit.hasNext();
		else{
			currentit = iteratots.get(++currentItIndex);
			if(currentit != null)
				return hasNext();
		}
		return ret;
	}
	
	public Object next(){
		Object ret = null;
		if(currentit.hasNext())
			ret = currentit.next();
		else {
			currentit = iteratots.get(++currentItIndex);
			if(currentit != null)
				return next();
		}
		return ret;
	}
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class FlattenedIterator<K> implements Iterator<K> {
	private List<Iterator<K>> itrs;
	private volatile Iterator<K> currentItr;
	private volatile int currentItrIndex;

	public FlattenedIterator(List<Iterator<K>> itrs) {
		if(itrs != null) {
			this.itrs = itrs;
			this.currentItr = itrs.get(0);
		} else {
			this.itrs = new ArrayList<Iterator<K>>(0);
			this.currentItr = null;
		}
		this.currentItrIndex = 0;
	}
	
	@Override
	public boolean hasNext() {
		if(this.currentItr == null) {
			return false;
		}
		do {
			if(this.currentItr.hasNext()) {
				break;
			} else {
				if(currentItrIndex + 1 < itrs.size()) {
					this.currentItr = itrs.get(++currentItrIndex);
				}
			}
		}while(currentItrIndex + 1 < itrs.size());
		return this.currentItr.hasNext();
	}

	@Override
	public K next() {
		if(this.currentItr == null) {
			return null;
		}
		do {
			if(this.currentItr.hasNext()) {
				return this.currentItr.next();
			} else {
				if(currentItrIndex + 1 < itrs.size()) {
					this.currentItr = itrs.get(++currentItrIndex);
				}
			}
		} while(currentItrIndex + 1 < itrs.size());
		return this.currentItr.next();
	}

	@Override
	public void remove() {
		if(this.currentItr != null) {
			do {
				if(this.currentItr.hasNext()) {
					this.currentItr.remove();
					return;
				} else {
					if(currentItrIndex > 0) {
						this.currentItr = itrs.get(--currentItrIndex);
					}
				}
			} while(currentItrIndex > 0);
			this.currentItr.remove();
		}
	}
}