Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

Java Collection vs Collections: Interface or Utility Class?

Java Collection vs Collections: Understand the difference between the Collection interface and the Collections utility class in Java, including usage and common methods.

~4 min readJava
#Java#Collections Framework#Collection Interface#Utility Class
A visual comparison of the Collection interface and the Collections utility class in Java, showing their roles in the Java Collections Framework.

The names Collection and Collections look similar, but they serve completely different roles in Java. Collection is an interface that defines the contract for storing groups of objects, while Collections is a utility class that provides static methods to operate on collections. This article explains the distinction and shows when to use each.

What Is the Collection Interface?

Collection is the root interface of the Java Collections Framework. It declares methods like add, remove, size, contains, and iterator. Most collection types, such as List, Set, and Queue, extend this interface. For example:

java
List<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob");

Here, List is a subinterface of Collection. The Collection interface itself is rarely used directly; instead, you work with its subtypes. It defines the common behavior that all collections share.

What Is the Collections Utility Class?

Collections is a final class that cannot be instantiated. It contains static methods that provide utility operations on collections. These methods include sorting, searching, reversing, shuffling, and creating unmodifiable or synchronized views. For example:

java
List<Integer> numbers = new ArrayList<>(); numbers.add(3); numbers.add(1); numbers.add(2); Collections.sort(numbers);

The sort method reorders the list in place. Unlike the Collection interface, Collections does not define a data structure; it provides algorithms and helpers.

Key Differences Between Collection and Collections

The table below summarizes the main differences:

AspectCollectionCollections
TypeInterfaceUtility class
PurposeDefines the contract for a data structureProvides static methods for collection operations
InstantiationCannot be instantiated; used via subtypesCannot be instantiated; all methods are static
Common usageDeclaring variables, method parameters, and return typesSorting, searching, synchronizing, and creating unmodifiable collections
ExampleCollection<String> c = new ArrayList<>();Collections.sort(list);

The most important distinction is that Collection is a type, while Collections is a class containing static methods. You use Collection to define what a collection can do; you use Collections to perform operations on collections.

Common Methods of Collections and How to Use Them

The Collections class provides many useful methods. Here are a few frequently used ones:

  • sort(List<T> list) – sorts the list into ascending order.
  • reverse(List<?> list) – reverses the order of elements.
  • shuffle(List<?> list) – randomly permutes the list.
  • unmodifiableList(List<? extends T> list) – returns an unmodifiable view.
  • synchronizedList(List<T> list) – returns a thread-safe view.

For example, to create an unmodifiable list:

java
List<String> original = new ArrayList<>(); original.add("A"); List<String> immutable = Collections.unmodifiableList(original); immutable.add("B"); // throws UnsupportedOperationException

The unmodifiableList method returns a view that throws an exception if you try to modify it. This is useful for exposing data without allowing changes.

When to Use Collection vs Collections in Real Code

You use Collection (or its subtypes) as the type for variables, parameters, and return values. This allows you to swap implementations without changing the code. For instance:

java
public void printAll(Collection<String> items) { for (String item : items) { System.out.println(item); } }

Here, printAll accepts any collection, whether it is a List, Set, or Queue. This flexibility is a core benefit of the Collection interface.

You use Collections when you need to perform operations on collections. For example, to sort a list, you call Collections.sort(). To get an unmodifiable version, you call Collections.unmodifiableList(). These methods are not part of the Collection interface because they are not inherent to the data structure itself; they are external algorithms.

Performance and Maintainability Considerations

The Collections class includes methods that can affect performance and thread safety. For instance, synchronizedList wraps a list to make it thread-safe, but this adds synchronization overhead for every operation. If you only read the list from multiple threads, consider using an unmodifiable collection or a concurrent collection from java.util.concurrent instead.

Creating unmodifiable views is cheap because they are views, not copies. However, they do not prevent the original collection from being modified. If you need a truly immutable collection, consider using List.of() or Set.of() from Java 9 onward, which return immutable collections.

When using Collections.sort(), the underlying list must be mutable. Sorting an unmodifiable list will throw an UnsupportedOperationException. Always check whether the collection is modifiable before calling mutating methods.

Common Mistakes and How to Avoid Them

A frequent mistake is trying to instantiate Collections:

java
Collections c = new Collections(); // compile error

Because the constructor is private, this will not compile. Similarly, some developers mistakenly use Collection as a class, but it is an interface.

Another mistake is using Collections methods on arrays. Arrays are not collections, so you must convert them first using Arrays.asList(). For example:

java
String[] arr = {"a", "b"}; List<String> list = Arrays.asList(arr); Collections.sort(list);

Remember that Arrays.asList returns a fixed-size list backed by the array. You cannot add or remove elements, but you can sort it.

Finally, be aware of the difference between Collection and Collections when reading code. Seeing Collection in a type declaration means you are dealing with a data structure. Seeing Collections before a method call means you are using a static utility.

Try matching browser tools

All tools

Small utilities that fit Java work — they run entirely in this browser tab, so nothing you paste leaves your device.

All Java guides

More in Java

All Java guides

The guides filed next to this one in Java, in library order.