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. Overview
Simply put, a Set is a collection that contains no duplicate elements. In Java, Set is an interface that extends the Collection interface.
In this quick tutorial, we’ll go through different ways of copying sets in Java.
2. Copy Constructor
One way of copying a Set is to use the copy constructor of a Set implementation:
Set<T> copy = new HashSet<>(original);A copy constructor is a special type of constructor that is used to create a new object by copying an existing object.
Here, we’re not really cloning the elements of the given set. We’re just copying the object references into the new set. For that reason, each change made in one element will affect both sets.
3. Set.addAll
The Set interface has an addAll method. It adds the elements in the collection to the target set. Therefore, we can use the addAll method to copy the elements of an existing set to an empty set:
Set<T> copy = new HashSet<>();
copy.addAll(original);4. Set.clone
Let’s keep in mind that Set is an interface that extends the Collection interface, therefore we need to refer to an object that implements the Set interface to create another instance of a Set. HashSet, TreeSet, LinkedHashSet, and EnumSet are all examples of Set implementations in Java.
All these Set implementations have a clone method since they all implement the Cloneable interface.
So, as another approach to copying a set, we can call the set’s clone method:
Set<T> copy = (Set<T>) original.clone();Let’s also note that cloning originally comes from the Object.clone. Set implementations override the clone method of the Object class. The nature of the clone depends on the actual implementation. For example, HashSet does only a shallow copy, though we can code our way to doing a deep copy.
As we can see, we are forced to typecast the cloned object to Set<T> since the clone method actually returns an Object.
5. JSON
Another approach to copy a set is to serialize it into a JSON String and create a new set from the generated JSON String. It’s also worth to note that for this approach all the elements in the set and referenced elements must be serializable and that we’ll be performing a deep copy of all the objects.
In this example, we’ll copy the set by using the serialization and deserialization methods of Google’s Gson library:
Gson gson = new Gson();
String jsonStr = gson.toJson(original);
Set<T> copy = gson.fromJson(jsonStr, Set.class);6. Apache Commons Lang
Apache Commons Lang has a class SerializationUtils that provides a special method – clone – that can be used to clone a given object. We can make use of this method to copy a set:
for (T item : original) {
copy.add(SerializationUtils.clone(item));
}Let’s note that SerializationUtils.clone expects its parameter to extend the Serializable class.
7. Collectors.toSet
Or, we can use Java 8’s Stream API with Collectors to clone a set:
Set<T> copy = original.stream()
.collect(Collectors.toSet());One advantage of the Stream API is that it provides more convenience by allowing us to use skips, filters, and more.
8. Using Java 10
Java 10 brings a new feature into the Set interface that allows us to create an immutable set from the elements of a given collection:
Set<T> copy = Set.copyOf(original);Note that Set.copyOf expects a non-null parameter.
9. Conclusion
In this article, we’ve explored different ways of copying sets in Java.
