are two general-purpose List implementations
in the Collection Framework, ArrayList and LinkedList,
which of the two List implementations you use
depends on your specific needs. If you need
to support random access, without inserting
or removing elements from any place to other
than the end, then ArrayList offers you the
optimal collection, the LinkedList class provides
uniformly named methods to get, remove and insert
an element at the beginning and end of the list.
ArrayList instance has a capacity. The capacity
is the size of the array used to store the elements
in the list. It is always at least as large
as the list size. As elements are added an ArrayList,
its capacity grows automatically. The details
of the growth policy are not specified beyond
the fact that adding an element has constant
amortized time cost.
application can increase the capacity of an
ArrayList instance before adding a large number
of elements using the ensureCapacity operation.
This may reduce the amount of incremental reallocation.
that these implementation is not synchronized.
If multiple threads access a set concurrently,
and at least one of the threads modifies the
set, it must be synchronized externally. This
is typically accomplished by synchronizing on
some object that naturally encapsulates the
set. If no such object exists, the set should
be "wrapped" using the Collections.synchronizedSet
method. This is best done at creation time,
to prevent accidental unsynchronized access
to the set:
list = Collections.synchronizedList(new ArrayList(...));