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
In this tutorial, we’ll learn how to construct a list containing primitive integer values.
We’ll explore solutions using core Java and external libraries.
2. Autoboxing
In Java, generic type arguments must be reference types. This means we can’t do something like List<int>.
Instead, we can use List<Integer> and take advantage of autoboxing. Autoboxing helps us use the List<Integer> interface as if it contained primitive int values. Under the hood, it is still a collection of Objects and not primitives.
The core Java solution is just an adjustment to be able to use primitives with generic collections. Moreover, it comes with the cost of boxing and unboxing conversions.
However, there are other options in Java and additional third-party libraries that we can use. Let’s see how to use them below.
3. Using the Stream API
Oftentimes, we don’t actually need to create a list as much as we just need to operate on it.
In these cases, it might work to use Java 8’s Stream API instead of creating a list altogether. The IntSream class provides a sequence of primitive int elements that supports sequential aggregate operations.
Let’s have a quick look at an example:
IntStream stream = IntStream.of(5, 10, 0, 2, -8);The IntStream.of() static method returns a sequential IntStream.
Similarly, we can create an IntStream from an existing array of ints:
int[] primitives = {5, 10, 0, 2, -8};
IntStream stream = IntStream.of(primitives);Moreover, we can apply the standard Stream API operations to iterate, filter and aggregate the ints. For example, we can calculate the average of the positive int values:
OptionalDouble average = stream.filter(i -> i > 0).average();Most importantly, no autoboxing is used while working with the streams.
Though, if we definitely need a concrete list, we’ll want to take a look at one of the following third-party libraries.
4. Using Trove
Trove is a high-performance library which provides primitive collections for Java.
To setup Trove with Maven, we need to include the trov4j dependency in our pom.xml:
<dependency>
<groupId>net.sf.trove4j</groupId>
<artifactId>trove4j</artifactId>
<version>3.0.2</version>
</dependency>With Trove, we can create lists, maps, and sets.
For instance, there is an interface TIntList with its TIntArrayList implementation to work with a list of int values:
TIntList tList = new TIntArrayList();Even though TIntList can’t directly implement List, it’s methods are very comparable. Other solutions that we discuss follow a similar pattern.
The greatest benefit of using TIntArrayList is performance and memory consumption gains. No additional boxing/unboxing is needed as it stores the data inside of an int[] array.
5. Using Fastutil
Another high-performance library to work with the primitives is Fastutil. Let’s add the fastutil dependency:
<dependency>
<groupId>it.unimi.dsi</groupId>
<artifactId>fastutil</artifactId>
<version>8.1.0</version>
</dependency>Now, we’re ready to use it:
IntArrayList list = new IntArrayList();The default constructor IntArrayList() internally creates an array of primitives with the default capacity of 16. In the same vein, we can initialize it from an existing array:
int[] primitives = new int[] {5, 10, 0, 2, -8};
IntArrayList list = new IntArrayList(primitives);6. Using Colt
Colt is an open source, a high-performance library for scientific and technical computing. The cern.colt package contains resizable lists holding primitive data types such as int.
First, let’s add the colt dependency:
<dependency>
<groupId>colt</groupId>
<artifactId>colt</artifactId>
<version>1.2.0</version>
</dependency>The primitive list that offers this library is cern.colt.list.IntArrayList:
cern.colt.list.IntArrayList coltList = new cern.colt.list.IntArrayList();The default initial capacity is ten.
7. Using Guava
Guava provides a number of ways of interfacing between primitive arrays and collection APIs. The com.google.common.primitives package has all the classes to accommodate primitive types.
For example, the ImmutableIntArray class lets us create an immutable list of int elements.
Let’s suppose, we have the following array of int values:
int[] primitives = new int[] {5, 10, 0, 2};We can simply create a list with the array:
ImmutableIntArray list = ImmutableIntArray.builder().addAll(primitives).build();Furthermore, it provides a list API with all the standard methods we would expect.
8. Conclusion
In this quick article, we showed multiple ways of creating lists with the primitive integers. In our examples, we used the Trove, Fastutil, Colt, and Guava libraries.
