ArrayList : Java Glossary

ArrayList is like Vector without the synchronisation overhead. In Java version 1.1 ArrayList is about 3-4 times faster than Vector, though with JDK (Java Development Kit) 1.1.4+ the difference is not so pronounced. (Rolling your own array is about 40 times faster than Vector.) For compatibily with versions of Java prior to Java version 1.1, you need to use Vector instead. Don’t use Vector in new code. It has confusing redundant methods, and the synchronisation is excessive and implicit.

You can check if a List is in order with com.mindprod.common15.InOrder.

Adding Elements to An ArrayList

// adding an element to the middle of a list
arrayList.add( i, object );

// adding an element to the end of a list
arrayList.add( object );

actually inserts, sliding existing elements up to make room. As you might guess, this is an expensive operation when there are many elements.

ArrayIndexOutOfBoundsException

• Using a negative index.
• Indexing past the current end of the ArrayList with get or set. It will only automatically grow with add, and it will grow only one element at a time. It won’t let you even use set one element past the end. setCapacity is of no help. It only increases the size of the internal array, not the logical array.
• Doing a lastIndexOf starting out past the end.

GrowingArrayList

With an ordinary ArrayList you can’t set elements until you have grown the ArrayList sufficiently first with add. If you try it, you will get an ArrayIndexOutOfBoundsException or IndexOutOfBoundsException.

If you want an ArrayList that grows automatically when you use a set index too big, here is the complete source code for it.

Removing Elements From An ArrayList

Trimming ArrayLists

When you are done removing elements, you have logically removed them, but the RAM (Random Access Memory) they had allocated is still nailed down, ready to use for future growth. If you want to reclaim it, you must use ArrayList. trimToSize(), which allocates a new internal array just the right size, and copies everything over from the new one, and discards the old one to be later garbage collected. You don’t normally want to use trimToSize unless you know the ArrayList is not going to grow again, any time soon. It is a relatively costly operation, so you don’t want to do it just to reclaim a handful of bytes. You might use it after a massive pruning, or after you were sure nothing new was coming.

When I am absolutely sure there are no new elements coming for the ArrayList, I typically use toArray and use the much faster raw array from then on. I think of ArrayLists mainly as tools to build a Collections, and I think of arrays as tools to process them. However, most other programmers are not nearly so keen as I am on naked arrays. They prefer to do everything with ArrayLists. when you use generics and for:each it is relatively easy to flip back and forth between each style.

ArrayList.add or ArrayList. addAll will not discard duplicates. To do that you would need to check with ArrayList.contains before adding, or create a HashSet which naturally dedups, then use ArrayList. addAll to effectively convert it to an ArrayList.

Gotchas

• Use ArrayList.set( index, value ) to set the value, not put.
• Unlike an array where you get the size with v.length, with an ArrayList you use v. size();
• You cannot grow an ArrayList with set. You must use add.
• ArrayLists may contain duplicates. If you want entries unique, you must manage that yourself.

ArrayList ⇔ array

More complex conversions can be handled by combining ArrayList. toArray, List.subList, Arrays.copyOf, Arrays. copyOfRange and System. arraycopy. subList does not make a copy. Any changes to the sublist are reflected in the original. System.arraycopy is quite general letting you pick the offset in both the source and destination. Arrays. copyOf creates a new array, grown or shrunk. Arrays. copyOfRange creates a new array, allowing you to specify the offset in the source.

Thread Safety of ArrayLists

To get the thread safety of Vector in ArrayList wrap it like this:

// making an ArrayList threadsafe
ArrayList a = new ArrayList( 100 );
Collection threadSafeList = Collections.synchronizedCollection( a );

Generics with ArrayLists

Using an ArrayList with generics:

Learning More