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 of ArrayList
In this quick tutorial, we’ll show to how to add multiple items to an already initialized ArrayList.
For an introduction to the use of the ArrayList, please refer to this article here.
2. AddAll
First of all, we’re going to introduce a simple way to add multiple items into an ArrayList.
First, we’ll be using addAll(), which takes a collection as its argument:
List<Integer> anotherList = Arrays.asList(5, 12, 9, 3, 15, 88);
list.addAll(anotherList);It’s important to keep in mind that the elements added in the first list will reference the same objects as the elements in anotherList.
For that reason, every amends made in one of these elements will affect both lists.
3. Collections.addAll
The Collections class consists exclusively of static methods that operate on or return collections.
One of them is addAll, which needs a destination list and the items to be added may be specified individually or as an array.
Here it’s an example of how to use it with individual elements:
List<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, 2, 3, 4, 5);And another one to exemplify the operation with two arrays:
List<Integer> list = new ArrayList<>();
Integer[] otherList = new Integer[] {1, 2, 3, 4, 5};
Collections.addAll(list, otherList);Similarly to the way explained in the above section, the contents of both lists here will refer to the same objects.
4. Using Java 8
This version of Java opens our possibilities by adding new tools. The one we’ll explore in the next examples is Stream:
List<Integer> source = ...;
List<Integer> target = ...;
source.stream()
.forEachOrdered(target::add);The main advantages of this way are the opportunity to use skip and filters. In the next example we’re going to skip the first element:
source.stream()
.skip(1)
.forEachOrdered(target::add);It’s possible to filter the elements by our necessities. For instance, the Integer value:
source.stream()
.filter(i -> i > 10)
.forEachOrdered(target::add);Finally, there are scenarios where we want to work in a null-safe way. For those ones, we can use Optional:
Optional.ofNullable(source).ifPresent(target::addAll)In the above example, we’re adding elements from source to target by the method addAll.
5. Conclusion
In this article, we’ve explored different ways to add multiple items to an already initialized ArrayList.
