Help with an Iterator question

I have been learning Java for 5-6 months, my friend passed me this question regarding iterator for the first time in my life I have no clue what this means, can someone help me?

// Implement the following CausataIterator class to behave as specified in the Javadoc
// (implement the methods and constructor marked with TODO).
// Your code must compile on Java 6 or 7, without the use of any external libraries
// (though you may use external libraries in your tests, if you wish).
/**
* Implementation of an {@link Iterator} that returns a SORTED stream of results from a
* collection of input {@link Iterator}s, where the values in the input iterators are also
* sorted.
*
* The values returned by the input iterators WILL ALWAYS BE SORTED according to the
* same {@link Comparator} that is specified in {@link CausataIterator}'s constructor.
* The input iterators will never contain <tt>null</tt>
*
* The input iterators are expected to have a very large (or possibly infinite) set of results,
* so this implementation returns results AS SOON AS THEY ARE AVAILABLE, rather than waiting
* until the input iterators are drained before returning results.
*
* This class can also eliminate duplicate values from the input iterators (making all output
* values distinct), if the <tt>eliminateDuplicates</tt> flag is set in the constructor. Note that
* the specified {@link Comparator} is used to determine if two objects are identical,
* rather than the objects' {@link #equals(Object)} methods.
*
* Note: this class is not thread-safe, and cannot be called concurrently
* from multiple threads
*/
public class CausataIterator<T> implements java.util.Iterator<T> {
 /**
 * Creates a {@link CausataIterator} with the specified collection of input {@link Iterator}s
 * and {@link Comparator}, eliminating duplicates if required.
 *
 * This constructor must NOT call the {@link Iterator#next()} or {@link #hasNext()}
 * methods of the input iterators, as these methods may block, and the constructor needs to
 * return as soon as possible.
 *
 * @param iterators The collection of input iterators, over which the results will be returned. The
 * values in these iterators WILL ALWAYS BE SORTED by the specified {@link Comparator}.
 *
 * @param comparator The {@link Comparator} that is to be used to compare items. The output values
 * returned from {@link #next()} will be ordered by this comparator, and the values in the input
 * iterators should also be ordered by it.
 *
 * @param eliminateDuplicates If this is set to <tt>true</tt> then the output values will contain
 * no duplicate values, according to the specified {@link Comparator}.
 */
 public CausataIterator(java.util.Collection<? extends java.util.Iterator<T>> iterators,
 java.util.Comparator<T> comparator, boolean eliminateDuplicates) {
 // TODO: Implement this constructor
 }

/**
    * @see Iterator#hasNext()
    */
    @Override
    public boolean hasNext() {
        // TODO: Implement this method
        return false;
    }

/**
 * Returns the next value from the input iterators, where values are returned in order,
 * according to the {@link Comparator} supplied in the
 * {@link #CausataIterator(Collection, Comparator, boolean)} constructor.
 *
 * @throws NoSuchElementException if there are no more values to return
 */
 @Override
 public T next() {
 // TODO: Implement this method
 return null;
 }

/**
    * Calling this method is not supported, and throws a {@link UnsupportedOperationException}
    */
    @Override
    public void remove() {
        throw new UnsupportedOperationException("Calling remove() is not supported");
    }
}

[Fixed code tags and formatting - see UseCodeTags for details]

Hello Jim Fields,

Welcome to CodeRanch!

Please, UseCodeTags. I can see a closing code tag, however, since, there is no opening code tag, the code snippet is quite difficult to read.

Also, please TellTheDetails. What exact part you are having trouble with? And what way of thinking you are following as of now?

I hope this helps.

Hi Jim, The code itself doesn't make sense, since mostly no usable body in it.
What it is actually tying to do is, create a customized Iterator class, but lack of body code, nothing more.
All the collection interfaces implements Iterator, and tats just enough for normal use.

Next time try to post your code bit formatted

Hi Jim. Welcome to the Ranch!

OK, what you've got there is a skeleton implementation of a custom Iterator. It looks like it's intended to wrap an existing iterator and add some additional functionality. Although as far as I can tell at first glance the additional functionality is just to optionally eliminate duplicates.

So the first question is, do you know what an Iterator is? If not, you need to read about those. If you do, you need to work out how to implement this one - you need to delegate to the wrapped Iterator, but then add whatever additional logic you need. What I'd suggest is as a first step get it delegating completely, so your Iterator works exactly the same as the one passed in. Then worry about the duplicates once you've got that working.

(A quick observation: getting a rough solution looks relatively straightforward. Getting a perfect one not so simple - I can see one tricky point).

Thanks a lot for the input guys, I guess I need to find out a way to implement the iterator functionality in this skelital implementation of this iterator...is that it???

Here is my solution:

[Moderator action: Solution removed. This site is NotACodeMill.(⇐click)]

Vineeth Menon wrote:Thanks a lot for the input guys, I guess I need to find out a way to implement the iterator functionality in this skelital implementation of this iterator...is that it???

Well, since we have:

I would say, yes, you need to do exactly that, as it appears to be the whole point of the exercise.

Sammy Wilson, welcome to the Ranch

Please note what it says on the contents page for this forum:

We're all here to learn, so when responding to others, please focus on helping them discover their own solutions, instead of simply providing answers.

That is why Jeff removed your post: it does not help people to be given too complete a solution too quickly.