Thread: Iterator

The API is your best friend. This is the first result for googling "Java iterator": Iterator (Java Platform SE 7 )

According to the API, it's an interface. But asking whether something is an interface or an object seems to miss the point: and object can be an interface.

Here is an example:

List is an interface. The ArrayList class is an implementation of that interface. Since an ArrayList *is a* List, you can have code like this:

List myList = new ArrayList();

The List interface only has method signatures, not their bodies. However, since myList is an ArrayList, I can still do things like this:

myList.add("test");

A similar thing happens with the Iterator interface.

Originally Posted by gautammuktsar@gmail.com

Well thank you . But one thing more in case of List interface ,class ArrayList is implementing List interface but my question is which class is implementing the Interface Iterator .

That depends on how you're getting the interface. It could be any number of classes.

Originally Posted by gautammuktsar@gmail.com

then could be necessary for the class which implements the Iterator to provide defination for their all 3 methods ??...but while using Iterator to transverse the elements of collection(container) we are not defining any of the methods..please give a short example

No, *you* give a short example. How are you getting your Iterator? What does the function that returns the Iterator actually do? You can access the source code of any Java method via the src.zip file in your JDK directory.

Like I said, your best bet is to look at the source for the Vector.iterator() function. It looks like this:

 /**
     * Returns an iterator over the elements in this list in proper sequence.
     *
     * <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     *
     * @return an iterator over the elements in this list in proper sequence
     */
    public synchronized Iterator<E> iterator() {
        return new Itr();
    }

And the Itr class is an inner class inside the Vector class. It looks like this:

    /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;
 
        public boolean hasNext() {
            // Racy but within spec, since modifications are checked
            // within or after synchronization in next/previous
            return cursor != elementCount;
        }
 
        public E next() {
            synchronized (Vector.this) {
                checkForComodification();
                int i = cursor;
                if (i >= elementCount)
                    throw new NoSuchElementException();
                cursor = i + 1;
                return elementData(lastRet = i);
            }
        }
 
        public void remove() {
            if (lastRet == -1)
                throw new IllegalStateException();
            synchronized (Vector.this) {
                checkForComodification();
                Vector.this.remove(lastRet);
                expectedModCount = modCount;
            }
            cursor = lastRet;
            lastRet = -1;
        }
 
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

But all you really need to know is that the iterator() function returns and implementation of the Iterator interface. An interface is simply a way of guaranteeing which functions you know you have. You know you have the functions declared by the Iterator interface in whatever object is returned by the iterator() function.