[catching up late, thanks to the time zones!]

Yes, maybe I wasn't clear in my messages but that's exactly what I
meant: I did try the ListIterator, with the add() method that comes
with it (rather than the one from the Collection) and yet I still get
the ConcurrentModificationException.

As for the other suggestions:
- Yes, there's a big performance issue--as the module is involved in a
big combinatorial decision problem--, so indeed my first choice is to
go for an ArrayList. I just mentioned the LinkedList because I think
what I want should be possible at least with that kind of structure,
where the dynamic changes are a main motivation for it.

- I also agree that the good old "do-it-yourself" solution, with a
simple array and an integer index that I would manage myself is
probably what I'll end up adopting. I just thought there would be a
nice-and-neat implementation out there, which would embed everything in
a Collection-like kind of solution with iterator and everything, that
you can use as a black box. But now it looks like there is nothing
available, really. Never mind, I'll go for the "old fashion" way ;-)

--
Jean-Philippe Prost  [E6A 341, x9542]
  Centre for Language Technology
  Macquarie University ~ Sydney, Australia
<http://www.ics.mq.edu.au/~jpprost/>
_______________________________________________

Isn't *called* LikedCollection, I meant to type.  (By implication,
implements Collection but not List.)

Suppose you're writing a method to process an arbitrary List.  As things
are, it's very wrong to write:

   void processList(List l)
   {
           for (int i = 0; i < l.size(); i++)
           {
                   Object member = l.get(i);
                    ...
           }
   }

since the performance could be horrific for a large LinkedList.  It must be
written as

   void processist(List l)
   {
           for (Iterator iter = l.iterator(); !iter.hasNext(); )
           {
               Object member = l.next();
               ...
           }
   }

Since the random access get() shouldn't be used on arbitrary lists, why is
it defined in the List interface?

The vast majority of *my* uses of Lists are serial access.  It is quite
rare that I both want some element in the middle of a List and also know
its index.  The most common exception is sorting, but I don't do that
often.  On the other hand, ArrayList is the List implementation I
usually use, whether I anticipate random access or not.