Linked List and String Resources

Question

Linked Lists can be very slow when removing dynamic Strings.
If you add and remove Strings in the
following way, the performance is very poor:
int n = 10000;
long time = System.currentTimeMillis ();
List list = new LinkedList();
for (int i = 0 ; i < n ; i++)
list.add ("" + n);
for (int i = n-1 ; i >= 0 ; i--)
list.remove(i/2);
- If you add and remove the not dynamic String: "" + 10000 instead,
- or do not remove the String (but add it in the middle),
- or use a ArrayList
the performance is much better.
I suppose it depends on handling the String resources.
If you run the following class, you will see what I mean:
public class SlowLinkedList
public static void main (String[] args)
// Be carefull when accessing/removing Strings in a Linked List.
testLinkedList ();
testLinkedListHardCodedString();
testLinkedListNoRemove();
testArrayList();
testArrayListNoParam();
private static void testLinkedList ()
int n = 10000;
long time = System.currentTimeMillis ();
List list = new LinkedList();
for (int i = 0 ; i < n ; i++)
list.add ("" + n);
for (int i = n-1 ; i >= 0 ; i--)
list.remove(i/2);
time = System.currentTimeMillis () - time;
System.out.println ("time dynamic String remove " + time);
private static void testLinkedListHardCodedString ()
int n = 10000;
long time = System.currentTimeMillis ();
List list = new LinkedList();
for (int i = 0 ; i < n ; i++)
list.add ("" + 10000);
for (int i = n-1 ; i >= 0 ; i--)
list.remove(i/2);
time = System.currentTimeMillis () - time;
System.out.println ("time same String remove " + time);
private static void testLinkedListNoRemove ()
int n = 10000;
long time = System.currentTimeMillis ();
List list = new LinkedList();
for (int i = 0 ; i < n ; i++)
list.add (i/2, "" + n);
time = System.currentTimeMillis () - time;
System.out.println ("time add dynamic String " + time);
private static void testArrayList ()
int n = 10000;
long time = System.currentTimeMillis ();
List list = new ArrayList();
for (int i = 0 ; i < n ; i++)
list.add ("" + n);
for (int i = n-1 ; i >= 0 ; i--)
list.remove(i/2);
time = System.currentTimeMillis () - time;
System.out.println ("time ArrayList " + time);
private static void testArrayListNoParam ()
int n = 10000;
long time = System.currentTimeMillis ();
List list = new ArrayList ();
for (int i = 0 ; i < n ; i++)
list.add ("" + 10000);
for (int i = n-1 ; i >= 0 ; i--)
list.remove(i/2);
time = System.currentTimeMillis () - time;
System.out.println ("time ArrayList same String " + time);
A typic output of the Performance is:
time dynamic String remove 1938
time same String remove 312
time add dynamic String 31
time ArrayList 63
time ArrayList same String 31

Answer 1

begin long winded reply
It doesn't matter if they are Strings or any other Object. LinkedList, in the way you are executing
remove, is not effecient. The LinkList remove will look at the index, if it is less than the median
it will start iterating from 0, if it is greater, it will start iterating in reverse from the end. Since you
are removing from the median, it will always take the longest (either forward or backward) to
get to the middle. Whereas, ArrayList simply uses the arraycopy to drop the element from the
array. The "NoRemove" test doesn't make sense to me in relation to the others.
Also, the VM is performing optimizations when you hardcode the 'n' value to 10000, it seems
that the VM won't optimize when using 'n'. Tusing Integer.toString(n), instead of "" + n,
in the first test case, it will yield better results.
My profs in college drove collections into my head and removing from a linked list without
an iterator is going to be inefficient. Iterators are a beautiful thing, use them.
Try this code instead, it simulates your remove in the middle with an iterator and, on my
machine, is faster than the ArrayList.
private static void testLinkedList() {
    int n = 10000;
    long time = System.currentTimeMillis ();
    List list = new LinkedList();
    for (int i = 0 ; i < n ; i++) {
        list.add (Integer.toString(n));
    boolean forward = false;
    for (ListIterator li = list.listIterator(n >> 1); li.hasNext() || li.hasPrevious();) {
        if (forward) {
            li.next();
            forward = false;
        } else {
            li.previous();
            forward = true;
        li.remove();
    time = System.currentTimeMillis () - time;
    System.out.println ("time dynamic String remove " + time);
}One other thing, run the tests more than once in a single VM and take the average. You could
apply some statistical analysis to figure out which is better within a certain confidence percentage,
but that is probably overkill. :)
Check the collection tutorial for more info: http://java.sun.com/docs/books/tutorial/collections/implementations/general.html
end long winded reply
Matt