For most Java code, choose ArrayList: it offers constant-time indexed access and amortized constant-time appends, with a low constant factor. Choose LinkedList when you need deque operations at both ends or already have an iterator at the position where edits occur. Use Vector mainly to preserve compatibility with legacy code that relies on its synchronized, older API.
How the three lists differ
| Feature | ArrayList | LinkedList | Vector |
|---|---|---|---|
| Storage | Resizable array; Oracle Java SE 17 API documents its behavior at ArrayList. | Doubly linked nodes; Oracle Java SE 17 API documents its behavior at LinkedList. | Array buffer; Oracle Java SE 17 API documents its behavior at Vector. |
| Indexed get and set | Constant time. | Linear traversal from the nearer end. | Array-backed indexed operations; methods are synchronized. |
| Append | Amortized constant time. | Constant-time end operation. | Array-backed; growth may require expanding the buffer, and methods are synchronized. |
| Insert or remove near the beginning | Linear time because later elements must shift. | Constant-time once the relevant node is reached; finding an indexed position still takes traversal. | Array shifts are required for indexed insertion or removal; methods are synchronized. |
| Concurrency behavior | Not synchronized. | Not synchronized. | Synchronized methods. |
| Interfaces and role | List, RandomAccess; general-purpose list. |
List, Queue, Deque; useful for deque-style operations. |
List and legacy Vector API. |
Which is faster: ArrayList or LinkedList?
There is no universal speed winner for every operation. For indexed reads and ordinary list use, ArrayList is generally the better starting point: indexing is constant time, and its append operation is amortized constant time. Oracle describes its constant factor as low relative to LinkedList.
LinkedList can perform operations at its ends in constant time, but indexed access is linear because it must traverse nodes. An insertion is not automatically fast just because linking nodes is cheap: if the list must first locate an index, that traversal remains part of the work. The Collections tutorial describes positional access as linear and advises measuring a real workload before replacing an ArrayList with a LinkedList. Its examples were written for JDK 8; the Java SE 17 API pages establish the version-specific contracts. See Oracle’s List Implementations tutorial.
The cited Oracle references provide complexity guarantees and qualitative comparisons, not a benchmark percentage or speed ratio. If performance is material, benchmark the operations and access patterns your application actually uses rather than assuming one collection is faster overall.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →When to choose each collection
Choose ArrayList for a typical list
- Use it when you read by index, iterate through elements, or append items in ordinary application code.
- Prefer it as the general-purpose default unless your access pattern gives another collection a clear advantage.
- If you know the approximate size, provide an initial capacity or use
ensureCapacityto reduce resizing as the list grows.
Choose LinkedList for deque operations or iterator-positioned edits
- Use it when you need the
DequeorQueueinterface and work is concentrated at the beginning and end. - It can also suit repeated structural edits when a
ListIteratoris already positioned at the edit point. - Avoid selecting it solely for an insertion at a numeric index: reaching that index still requires traversal.
Choose Vector for a specific legacy requirement
Vectordates to Java 1.0 and synchronizes its methods. Oracle recommendsArrayListinstead when a thread-safe implementation is not needed.- Keep it when compatibility with existing code or its historical API is an explicit requirement; otherwise, it is not the usual choice for new general-purpose lists.
- Its default internal array capacity is 10. Growth can use a configured capacity increment or doubling, as documented in the Java SE 17 Vector API.
What synchronization does—and does not—guarantee
ArrayList and LinkedList are not synchronized. If multiple threads share one of these lists and perform structural mutations, coordinate access externally. Vector synchronizes its methods, but that does not automatically make a sequence of multiple method calls atomic: compound operations still need a deliberate synchronization strategy.
For shared mutable data, decide on a concurrency design for the complete operation and access pattern rather than choosing a collection based only on the word “synchronized.” The cited APIs describe each collection’s synchronization behavior; they do not prescribe one design for every application.
Rank #2
Capacity and growth considerations
ArrayList accepts an initial capacity and provides ensureCapacity, which can help when the likely size is known. This is a capacity optimization, not a change to its indexed-access or append complexity. Vector likewise uses an internal array, starts with a default capacity of 10, and supports a configured growth increment or doubling. The documented growth behavior does not make it interchangeable with a linked structure: indexed insertion and removal still involve array shifts.
Quick Recap
Best Value
Rank #4
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Recommended Free Tools
