Can a collection have multiple iterators in Java?

Is it possible to have multiple iterators in a single col开发者_如何学JAVAlection and have each keep track independently? This is assuming no deletes or inserts after the iterators were assigned.

Yes.

Sometimes it's really annoying that answers have to be 30 characters.

Yes, it is possible. That's one reason they are iterators, and not simply methods of the collection.

For example List iterators (defined in AbstractList) hold an int to the current index (for the iterator). If you create multiple iterators and call next() a different number of times, each of them will have its int cursor with a different value.

Yes and no. That depend of the implementation of the interface Iterable<T>.

Usually it should return new instance of a class that implement Iterable interface, the class AbstractList implements this like that:

public Iterator<E> iterator() {
    return new Itr(); //Where Itr is an internal private class that implement Itrable<T>
}

If you are using standard Java classes You may expect that this is done this way.

Otherwise You can do a simple test by calling iterator() form the object and then run over first and after that second one, if they are depend the second should not produce any result. But this is very unlikely possible.

You could do something like this:

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

public class Miterate {

    abstract class IteratorCaster<E> implements Iterable<E>, Iterator<E> {
        int mIteratorIndex = 0;

        public boolean hasNext() {
            return mStorage.size() > mIteratorIndex;
        }

        public void remove() {
        }

        public Iterator<E> iterator() {
            return this;
        }
    }

    class FloatCast extends IteratorCaster<Float> {
        public Float next() {
            Float tFloat = Float.parseFloat((String)mStorage.get(mIteratorIndex));
            mIteratorIndex ++;
            return tFloat;
        }
    }

    class StringCast extends IteratorCaster<String> {
        public String next() {
            String tString = (String)mStorage.get(mIteratorIndex);
            mIteratorIndex ++;
            return tString;
        }
    }

    class IntegerCast extends IteratorCaster<Integer> {
        public Integer next() {
            Integer tInteger = Integer.parseInt((String)mStorage.get(mIteratorIndex));
            mIteratorIndex ++;
            return tInteger;
        }
    }

    ArrayList<Object> mStorage;

    StringCast mSC;
    IntegerCast mIC;
    FloatCast mFC;

    Miterate() {
        mStorage = new ArrayList<Object>();

        mSC = new StringCast();
        mIC = new IntegerCast();
        mFC = new FloatCast();


        mStorage.add(new String("1"));
        mStorage.add(new String("2"));
        mStorage.add(new String("3"));
    }

    Iterable<String> getStringIterator() {
        return mSC;
    }

    Iterable<Integer> getIntegerIterator() {
        return mIC;
    }

    Iterable<Float> getFloatIterator() {
        return mFC;
    }

    public static void main(String[] args) {
        Miterate tMiterate = new Miterate();

        for (String tString : tMiterate.getStringIterator()) {
            System.out.println(tString);
        }

        for (Integer tInteger : tMiterate.getIntegerIterator()) {
            System.out.println(tInteger);
        }

        for (Float tFloat : tMiterate.getFloatIterator()) {
            System.out.println(tFloat);
        }
    }
}

With the concurrent collections you can have multiple iterators in different threads even if there inserts and deletes.