Free tools Windows power users keep installed
One-click scans. No signup required.
The Java Collections Framework is Java’s standard architecture for storing and working with groups of objects. It gives programs common interfaces—such as List, Set, and Queue—and reusable implementations and algorithms, so code can use a collection’s behavior without depending on how that collection stores its data. Choose an interface based on the operations you need, then choose an implementation based on ordering, uniqueness, access patterns, and concurrency requirements.
What is the Java Collections Framework?
Oracle describes the Collections Framework as “a unified architecture for representing and manipulating collections, enabling them to be manipulated independently of the details of their representation.” In practice, it combines interfaces, concrete implementations, and utility algorithms. This shared design reduces the work of building collection-handling code and helps unrelated APIs interoperate. Oracle’s Collections Framework overview explains the architecture and its goals.
The framework is interface-first: declare a variable using the behavior your code needs, then instantiate an implementation that provides it. For example, a method accepting List<String> can work with different list implementations without needing to know their internal representation.
How the collection interfaces differ
Collection is the root interface in the collection hierarchy. A collection is a group of objects; whether duplicates are allowed and whether encounter order is defined depend on its more specific type and implementation. The JDK generally supplies concrete classes for these specific interfaces rather than a general-purpose Collection class. The Collection API documents the root interface.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →#1 Best Overall
| Type | What it represents | Typical reason to use it |
|---|---|---|
List |
An ordered collection, generally allowing duplicates and positional access. | Keep elements in sequence, retrieve or replace by index, or preserve repeated values. |
Set |
A collection that forbids duplicate elements; ordering depends on the implementation. | Enforce uniqueness. |
Queue |
A collection designed to hold elements before processing. | Process items according to the queue implementation’s policy. |
Deque |
A double-ended queue supporting insertion and removal at both ends. | Use the same structure as a queue or stack, or operate at either end. |
Map |
A mapping from keys to values; it is a peer of the Collection hierarchy, not a subtype of Collection. |
Look up a value by its key. |
These types are not interchangeable. In particular, a Map stores key-value associations and does not extend Collection, even though it is part of the broader Collections Framework. Oracle’s framework overview describes the interfaces and their relationships.
Which implementation should you choose?
Start with the required behavior, not the class name. The table summarizes common general-purpose choices and the reason to introduce each one. These implementations are unsynchronized by default; shared mutable state across threads may require a different design.
| Need | Typical implementation | Reason to choose it |
|---|---|---|
| General resizable list | ArrayList |
Resizable-array representation. |
| Linked sequence or list/deque operations | LinkedList |
Linked-list representation and both list and deque APIs. |
| General unique-element set | HashSet |
Hash-table set implementation. |
| Unique elements in insertion order | LinkedHashSet |
Hash table plus linked list, preserving insertion order. |
| Sorted unique elements | TreeSet |
Balanced-tree navigable set. |
| Queue or deque | ArrayDeque |
Array-backed queue/deque implementation. |
| General key-value lookup | HashMap |
Hash-table map implementation. |
| Key-value pairs retaining encounter order | LinkedHashMap |
Hash table plus linked list, retaining encounter order. |
| Sorted keys and navigable map operations | TreeMap |
Balanced-tree map implementation. |
Oracle’s overview of implementations maps these classes to resizable arrays, linked lists, hash tables, linked hash tables, and balanced trees. The choice is a trade-off: consider uniqueness, encounter order, sorted order, positional access, queue/deque behavior, expected lookup and update patterns, memory overhead, and whether synchronization or a concurrent implementation is needed. No single implementation is best for every pattern.
ArrayList or LinkedList?
Use ArrayList as a general resizable list when its array-backed representation fits the job. Choose LinkedList when its linked representation and list/deque APIs are useful to the design. The framework overview establishes these representations, but it does not provide a benchmark or a universal performance crossover; avoid choosing solely from a blanket claim that one is always faster.
HashSet or TreeSet, HashMap or TreeMap?
Choose the hash-based type when you need a general set or map and do not require sorted traversal. Choose TreeSet or TreeMap when sorted order or navigable operations are part of the requirement. Choose LinkedHashSet or LinkedHashMap when retaining encounter order is the key requirement. These order guarantees are distinct: insertion/encounter order is not the same as sorted order.
Algorithms and wrappers in Collections
The Collections utility class provides algorithms that operate on collections. Oracle documents sort(List), binarySearch(List, Object), reverse(List), shuffle(List), and fill(List, Object) among them. sort is stable, meaning equal elements retain their relative order, and its API documentation guarantees O(n*log n) performance. The Collections API lists the methods and their contracts.
Rank #4
The same utility class provides wrapper factories that add behavior around an existing collection:
unmodifiablereturns a view that throwsUnsupportedOperationExceptionwhen modification is attempted through that view.synchronizedreturns a synchronized view backed by the supplied collection. Thread safety depends on all accesses going through the returned wrapper.checkedreturns a dynamically type-safe view and throwsClassCastExceptionif an incorrectly typed element is added.
These are views, not replacements that make an independent copy of the supplied collection. In particular, direct access to the backing collection outside a synchronized wrapper bypasses that wrapper’s synchronization.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesWhen should you use concurrent collections?
When multiple threads share mutable collection state, consider the concurrent types in java.util.concurrent rather than assuming an ordinary general-purpose implementation is thread-safe. Oracle lists ConcurrentMap, ConcurrentNavigableMap, ConcurrentHashMap, ConcurrentSkipListMap, ConcurrentSkipListSet, and blocking queues and deques as framework options. Blocking queues and deques are relevant when coordination includes waiting for an item or capacity, rather than only storing and retrieving values. Pick a concurrent type that matches the required map, set, ordering, or blocking behavior; concurrency is not a reason to change collection semantics unnecessarily. Oracle’s overview identifies these concurrent options.
What changed with sequenced collections in Java 21?
JDK 21 added sequenced collection interfaces to represent collections with a defined encounter order and provide uniform operations across them. Oracle’s Java SE 26 developer guide notes that before JDK 21 the framework lacked a collection type representing a sequence of elements with defined encounter order. This is an API evolution, not a change that makes every set or collection ordered: the chosen type and implementation still determine whether encounter order exists. See the Java SE 26 Collections Framework guide for the current overview.
Quick Recap
A quick decision path
- If elements are addressed by keys, start with
Map; otherwise choose amongList,Set, andQueue/Dequebased on required behavior. - If duplicates must be allowed and position matters, use
List. For a general resizable list, begin withArrayList. - If duplicates are forbidden, use
Set: chooseHashSetfor general uniqueness,LinkedHashSetfor insertion order, orTreeSetfor sorted unique elements. - If keys map to values, choose
HashMapfor general lookup,LinkedHashMapto retain encounter order, orTreeMapfor sorted keys and navigable operations. - If items wait for processing or must be added and removed at both ends, use a queue/deque implementation such as
ArrayDeque. - If several threads share mutable state, select a suitable concurrent collection or deliberately use a synchronized wrapper and ensure every access goes through it.
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.
