Amitsh Amitsh - 10 months ago 47
Java Question

How to copy an iterator to another one?

I need to iterate over the set of values for each iteration of for loop, but only for first iteration it works fine. Thereafter the


Iterator<String> itr = getQuestionIterator(File file);

for(Person p : persons)
String question =;

This behaviour is clear to me.

One solution could be calling
getQuestionIterator(File file)
method in for loop so for each for loop iteration it gets reinitialized. But this is very inefficient approach as
is independent.

I tried this
Iterator<String> temp = itr
, but it didn't work also as it holds the reference only.

Is there any way to copy the iterator into another one or any other better approach?

Answer Source

An Iterator is the smallest possible API to work off data sequentially, hence it abstracts from the underlying data source. As it can only move forwards (next()) without any option to reset or rewind, it is a one-way object that must be thrown away after usage. And due to the limited API it offers, it is not possible to simply "copy" it without knowing the implementation and/or the underlying data source.

So there are four ways to handle your problem:

(1) Re-aquire a new iterator from the underlying data source

Just call getQuestionIterator(File file) every time you need to iterate over the data (again).

  • Advantage: Easy to use, easy to implement. No cache required.
  • Disadvantage: Performance (e.g. file has to be read/parsed again). Underlying data source might have been changed in the meantime.

(2) Combine all processing code into one single iterating loop

Instead of...

while (iterator.hasNext()) { /* first processing step */ }
while (iterator.hasNext()) { /* second processing step */ }
while (iterator.hasNext()) { /* third processing step */ }

...combine all steps:

while (iterator.hasNext()) {
    String question =;
    /* first processing step */
    /* second processing step */
    /* third processing step */
  • Advantage: Only one iterator required. No cache required.
  • Disadvantage: Not always possible, e.g. if processing steps have dependencies.

(3) Copy all elements into a local cache (Collection)

Iterate over all items once and put them into a local collection that you can use to aquire an arbitrary number of iterators:

// read everything into a local cache
Collection<String> cache = new ArrayList<>();
while (iterator.hasNext()) cache.add(;

// now you can get as many iterators from cache as required:
Iterator<String> iter = cache.iterator();
// use iter

iter = cache.iterator(); // once more
// use iter
  • Advantage: Simple to implement, fast, once all data is in the cache.
  • Disadvantage: Additional memory for cache required.

(4) Modify your data source API to let its implementation handle the problem

Meaning: Change getQuestionIterator(File file) to return an Iterable<String> instead of an Iterator<String>. You can gain an arbitrary number of iterators from an Iterable:

Iterable<String> iterable = getQuestionIterator(File file);
Iterator<String> iter = iterable.iterator();
// use iter

iter = iterable.iterator(); // once more
// use iter
  • Advantage: The underlying data source knows best how to cache your data. No need to copy your data in case the underlying data source already uses a cache.
  • Disadvantage: It is not always possible to change the API.