Detailed explanation
Collection and Collections are different types in the java.util package. Collection<E> is an interface that represents a group of elements and defines common operations such as add(), remove(), contains(), size(), and iterator(). Collections is a utility class that provides static methods for working with collections. The simplest distinction is that Collection describes what a collection object can do, while Collections provides helper operations that act on collection objects. This distinction matters when choosing variable types, reading API documentation, and deciding where a particular operation belongs.
Collection is the root interface of the collection hierarchy, with List, Set, and Queue as important subinterfaces. List generally preserves element position and permits duplicates; Set rejects duplicate elements; Queue models elements waiting for processing. Implementations such as ArrayList and HashSet supply concrete behaviour. Collection itself extends Iterable, which enables enhanced for-loop traversal. Map belongs to the Java Collections Framework but does not extend Collection because it represents key-value mappings rather than individual elements. Also, some Collection operations are optional: an implementation may throw UnsupportedOperationException when a requested modification is unsupported.
Collections cannot be instantiated through a public constructor; its methods are called directly on the class. For example, List<Integer> list = new ArrayList<>(List.of(3, 1, 2)); followed by Collections.sort(list); produces [1, 2, 3]. Collections.sort() modifies the supplied list rather than returning a new sorted list. Its natural-order overload requires mutually comparable elements, while another overload accepts a Comparator. Other helpers include reverse(), shuffle(), min(), max(), and binarySearch(). Not every helper accepts every Collection: sorting requires a List, and binary search requires a list already sorted using the same ordering.
Collections also provides wrappers with specific guarantees. Collections.unmodifiableList(list) creates an unmodifiable view, not an independent immutable copy: changes through the backing list remain visible. Collections.synchronizedList(list) wraps individual operations with synchronization, but iteration still requires explicit synchronization on the returned list. Interviewers typically look for the interface-versus-utility-class distinction, a correct example, and awareness that Map sits outside the Collection hierarchy. Explaining mutation and wrapper behaviour demonstrates understanding beyond memorising similarly named APIs.
Key points to remember
- Collection<E> is an interface; Collections is a utility class with static methods.
- List, Set, and Queue extend Collection; Map does not.
- Collection defines common operations such as add(), remove(), size(), and iterator().
- Collections supplies helpers such as sort(), reverse(), min(), and max().
- Unmodifiable and synchronized wrappers have different guarantees; neither automatically creates an independent copy.
Common mistakes candidates make
- Saying Collection is a class or that Collections is an interface.
- Claiming Map extends Collection because it belongs to the Java Collections Framework.
- Assuming Collections.sort() returns a new list or unmodifiableList() creates an immutable snapshot.
Likely follow-up questions
Can we instantiate Collection directly?
No, Collection is an interface. You can declare Collection<Integer> values = new ArrayList<>();, using the interface as the reference type and a concrete implementation as the object.
Why wrap List.of(3, 1, 2) in an ArrayList before sorting?
List.of(), available since Java 9, returns an unmodifiable list, so sorting it throws UnsupportedOperationException. Creating an ArrayList copies its elements into a mutable list that supports sorting.
How are Collections.unmodifiableList() and Collections.synchronizedList() different?
unmodifiableList() prevents modifications through the returned view but reflects changes made through the backing list. synchronizedList() synchronizes individual operations through the wrapper; traversal must still be enclosed in a synchronized block using that wrapper as the lock.
Interview tip: Start with “Collection is an interface; Collections is a utility class,” then show one sorting example and clarify that Map does not extend Collection.