Suck it and see.

You should find a long LinkedList is absolutely terrible for random access.

Unfortunately ArrayList isn't cyclic, removing from the head will cost.
It probably wont cost as much as a random access on a long LinkedList.
Removing from the head of an array list, just involves a block move of
pointers. Making your way through a linked list involves accessing large
amounts of memory (whether randomly or sequentially will likely depend
upon GC algorithm).

If you do lots of inserts/removes on heads and tails separately, perhaps
you could get away with reversing the list from time to time or
inserting/removing a block at a time.

For small lists, you may find different results apply.

You might be able to find a CyclicArrayList implementation somewhere (or
write your own if it is important). Java 1.6 will have Deque and in
particular ArrayDeque, unfortunately neither support random access.

Tom Hawtin

For a lot of random access, it's actually better to use the
java.util.TreeSet especially since you specified an ordered set.

LinkedList are better when you don't have an order or a set.
and ArrayList when you are more worried about the adding execution time.

Ben

When you do your random access, how do you select the element? By value,
or by index?

Patricia

What you want is a random access List-like structure that has both negative
and positive indices, and where both start and end index can chance.
Operations at the head increment and decrement the start index, operations
at the tail increment and decrement the end index.  This can easily be built
using two ArrayLists, one for the negative indices and one for the
non-negative.  You'll need to keep track of the current start and end
indices.  You'll also need to keep track of the current actual sizes of the
ArrayLists, so that you know whether an insert at the head (or tail) is a
set() or an add().

I've been thinking about all the operation I have to do with my set andf
I've found out that

1) I've to read all the elements (in order) : I can do it with a
listiterator
2) Given the current element (pointed by the listIterator) (i-th element) I
have to find the previous element (that is NOT necessarly (i-1))
3) Given the current element (pointed by the listIterator) (i-th element) I
have to find the next element (that is NOT necessarly (i+1))
4) I've to do some operation with the 3 elements (modify the current
element)
5) I've to move "up" or "down" the current element

I think that, in this case, the best solution would be a LinkedList.
I'm not able to execute operations 2) and 3).

I'd like to create 2 new listIterator "cloning" the one I have that points
to the current element.
With the first I will execute operation 2 and with the other operation 3.

//pseudo code
ListIterator curr=myset.listIterator();
while(curr.hasNext()){
   //get element
   MyObject obj=(MyObject)curr.next();

   //create listIterator
   ListIterator findPrec=curr;
   ListIterator findNext=curr;

   //find previous element moving findPrec
   !!!! if I move findPrec I'll move also findNext and curr

   //find previous element moving findNext
   !!!! if I move findNext I'll move also findPrec and curr
}

Is there a way to do what I want to?

Thanks
Vanessa