Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
1. Introduction
In this tutorial, we’re going to discuss how to choose the proper collection interface and class in the Java library. We skip legacy collections, such as Vector, Stack, and Hashtable in our discussion as we need to avoid using them in favor of the new collections. Concurrent collections deserve a separate topic, so we don’t discuss them either.
2. Collection Interfaces in the Java Library
It’s very useful to know the organization of the collection interfaces and classes in the Java library before trying to use them efficiently. The Collection interface is the root of all the collection interfaces. List, Set, and Queue interfaces extend the Collection.
Maps in the Java library are not treated as regular collections, so the Map interface doesn’t extend Collection. Here’s the diagram for interface relationships in the Java library:
Any concrete collection implementation (collection class) is derived from one of the collection interfaces. The semantics of collection classes are defined by their interfaces, as concrete collections provide specific implementations for operations that their parent interfaces define. Consequently, we need to choose the proper collection interface before selecting the suitable collection class.
3. Choose the Right Collection Interface
Choosing the right collection interface is somewhat straightforward. Indeed, the diagram below shows a logical interface selection flow:
To summarize, we use lists when the insertion order of elements matters and there are duplicate elements. Sets are used when elements are treated as a set of objects, there are no duplicates, and the insertion order doesn’t matter.
Queues are used when LIFO, FIFO, or removal by priority semantics is required, and finally, maps are used when the association of keys and values is needed.
4. Choose the Right Collection Implementation
Below we can find the comparison tables of collection classes separated by the interfaces they implement. The comparisons are made based on common operations and their performance. Specifically, the performance of operations is estimated using Big-O notation. A more practical guide to operations’ duration in Java collections can be found in the benchmark of collection operations.
4.1. Lists
Let’s start with a list comparison table. Common operations for lists are adding and removing elements, accessing an element by index, traversal of the elements, and finding an element:
| Lists Comparison Table | Add/remove element in the beginning | Add/remove element in the middle | Add/remove element in the end | Get i-th element (random access) | Find element | Traversal order |
|---|---|---|---|---|---|---|
| ArrayList | O(n) | O(n) | O(1) | O(1) | O(n), O(log(n)) if sorted | as inserted |
| LinkedList | O(1) | O(1) | O(1) | O(n) | O(n) | as inserted |
As we can see, ArrayList is good at adding and removing elements in the end, as well as having random access to elements. Conversely, it’s bad at adding and removing elements at arbitrary positions. Meanwhile, LinkedList is good at adding and removing elements at any position. However, it doesn’t support true O(1) random access. So, regarding lists, the default choice is ArrayList until we need fast element addition and removal at any position.
4.2. Sets
For sets, we’re interested in adding and removing elements, traversal of elements, and finding an element:
| Sets Comparison Table | Add element | Remove element | Find element | Traversal order |
|---|---|---|---|---|
| HashSet | amortized O(1) | amortized O(1) | O(1) | random, scattered by the hash function |
| LinkedHashSet | amortized O(1) | amortized O(1) | O(1) | as inserted |
| TreeSet | O(log(n)) | O(log(n)) | O(log(n)) | sorted, according to elements comparison criterion |
| EnumSet | O(1) | O(1) | O(1) | according to the definition order of the enum values |
As we can see, the default choice is the HashSet collection, as it’s very fast for all the operations it supports. Furthermore, if also the insertion order of elements matters, we go with LinkedHashSet. Basically, it’s an extension of HashSet, which keeps track of elements’ insertion order by using a linked list structure internally.
If the elements need to be sorted and the sorted order needs to be preserved while adding and removing elements, then we go with TreeSet.
If the elements of the set are just enumeration values of a single enum type, then the wisest choice is EnumSet.
4.3. Queues
Queues can be divided into two groups:
- LinkedList, ArrayDeque – Queue interface implementations can act as the stack, queue, and dequeue data structures. Generally, ArrayDeque is faster than LinkedList. Hence it’s the default choice
- PriorityQueue – Queue interface implementation backed by the binary heap data structure. Used for fast (O(1)) element retrieval, which has the highest priority. Addition and removal work in O(log(n)) time
4.4. Maps
Similarly to sets, we consider the operations of adding and removing elements, traversal of elements, and finding an element for maps:
| Maps Comparison Table | Add element | Remove element | Find element | Traversal order |
|---|---|---|---|---|
| HashMap | amortized O(1) | amortized O(1) | O(1) | random, scattered by the hash function |
| LinkedHashMap | amortized O(1) | amortized O(1) | O(1) | as inserted |
| TreeMap | O(log(n)) | O(log(n)) | O(log(n)) | sorted, according to elements comparison criterion |
| EnumMap | O(1) | O(1) | O(1) | according to the definition order of the enum values |
The selection logic for maps is similar to the selection logic for sets: we use HashMap by default, LinkedHashMap if additionally, insertion order is important, TreeMap for sorting, and EnumMap when keys belong to values of a specific enum type.
Lastly, there are two implementations of the Map interface, which have very specific applications: IdentityHashMap, and WeakHashMap.
5. Concrete Collection Selection Diagram
We can extend the diagram for choosing the proper collection interface for selecting concrete collection implementations:
6. Conclusion
In this article, we went through collection interfaces and collection classes in the Java library. Moreover, we proposed methods for selecting the correct interface and implementation.
