Add element to the end of a Java LinkedList while iterating it

Question

I'm iterating a java.util.LinkedList and in some cases I add an element to it.

LinkedList<Schedule> queue = new LinkedList<Schedule>(schedules);
ListIterator<Schedule> iterator = queue.listIterator();
while (iterator.hasNext()) {
    Schedule schedule = iterator.next();
    if(condition)
        iterator.add(new Schedule());
} 

The problem is that if I start for example with one item, the new item is added before the next iterator.next() call and the iteration exits.

How can I append the item at the end of the LinkedList while iterating? Please don't tell me to use another list and iterate it after the first because it doesn't solve my problem correctly.

Answer 1

If you cannot use another list, you could solve your problem by keeping a count of the number of elements you processed via the iterator and compare that to the original size of the list: all new element will be at the end of the list, so you can end your loop when you have reached the original size.

LinkedList<Schedule> queue = new LinkedList<Schedule>(schedules);
int origSize = queue.size();
int currCount = 0;
ListIterator<Schedule> iterator = queue.listIterator();
while (iterator.hasNext()) {
  ++currCount;
  if (currCount >= origSize) {
    break; // reached the end of the original collection
  }
  Schedule schedule = iterator.next();
  if(condition)
    iterator.add(new Schedule());
} 

You could also use an extra list to keep track of the new elements and add that to the original list after the processing is over:

LinkedList<Schedule> queue = new LinkedList<Schedule>(schedules);
LinkedList<Schedule> addQueue = new LinkedList<Schedule>();
ListIterator<Schedule> iterator = queue.listIterator();
while (iterator.hasNext()) {
  Schedule schedule = iterator.next();
  if(condition)
    addQueue.add(new Schedule());
} 
queue.addAll(addQueue);

Also, note that iterator.add()

Inserts the specified element into the list (optional operation). The element is inserted immediately before the next element that would be returned by next, if any, and after the next element that would be returned by previous, if any. (If the list contains no elements, the new element becomes the sole element on the list.) The new element is inserted before the implicit cursor: a subsequent call to next would be unaffected, and a subsequent call to previous would return the new element. (This call increases by one the value that would be returned by a call to nextIndex or previousIndex.)

so if you have more than one elements in the list, it will not add the new ones to the end, but between the current one and the one returned by next(). If you indeed want to place the new elements at the end of the list, use queue.add(...)

In general, it is not advisable to modify a collection while traversing it via an iterator, so I suggest you use the second approach (collect the extra elements in a separate list and add them to the original at the end)

Answer 2

Assuming you don't have a hard requirement to use an iterator then you can just shelve it and 'iterate' over the list by index instead:

LinkedList<Schedule> list;

for (int i = 0; i < list.size(); i++) {
   final Schedule schedule = list.get(i);
   if(condition)
       list.add(new Schedule());
}

Answer 3

As others have suggested, there is no efficient, off-the-shelf support for end-insertion during iteration in the current Collections framework. One suggestion involved rewriting the iterator. But I say, why not go a couple steps further?

1. Use reflection to modify the accessibility of the Node class, which gives you references to the double links, so you don't need to start iteration over with get(index), which should not be used in performant code.

2. Inherit/derive from LinkedList and override judiciously.

3. This is a no-brainer, but in the same spirit as 2 above, since the JDK is open-source, borrow the source as needed and write your own implementation.

In either case, I really feel this feature should be provided by Java LinkedList API.

Answer 4

How can I append the item at the end of the LinkedList while iterating?

public void addWork(Scheduler scheduler)
{
 synchronized(scheduler)
 {
  queue.addLast(scheduler);
 }
}

and you can use queue.removeFirst() to deal with item in the queue from top-to-down.

public synchronized Scheduler getWork()
{
  return queue.removeFirst();
}

Edited.

Answer 5

The requirements to add while iterating and include the added items in the iteration can only be met if you don't use an iterator for iteration since there is no way to recompute the state of your iterator every time an element is added. If you accept the less efficient get method to do your iteration, the problem is trivial. For example

LinkedList<Schedule> queue = new LinkedList<Schedule>(){{add(new Schedule());add(new Schedule());add(new Schedule());}};
int i = 0;
// queue.size() is evaluated every iteration
while (i < queue.size()) {
    Schedule schedule = queue.get(i);
    if(i++ % 2 == 0)
        queue.add(new Schedule());
}
System.out.println(queue.size());

prints 6 as expected.