FastUtil is a Java library of type-specific maps, sets, lists, queues and related utilities. Its primitive-specialized collections can avoid much of the boxing and wrapper-object overhead associated with collections such as Map<Integer, V> and ArrayList<Integer>. That can make it a useful option for numeric-heavy or very large workloads—but it does not guarantee a faster or smaller application. Choose it for a measured workload, then benchmark the operations and data sizes your program actually uses.
What is FastUtil?
FastUtil extends the Java Collections Framework with type-specific collections and utilities. Its official project describes the library as providing “type-specific maps, sets, lists and queues with a small memory footprint and fast access and insertion.” FastUtil on GitHub
The key distinction is primitive specialization. A regular generic collection stores reference types, so an integer used as a key or list element is represented through the Integer wrapper type. FastUtil offers alternatives specialized for primitive types, such as integer-keyed maps and integer lists, which can reduce wrapper-related overhead in suitable code. It also has collections for object or reference use cases.
FastUtil includes more than everyday collection classes: the project documents big arrays and lists with 64-bit indexing, sorting helpers, bidirectional iterators, primitive stream support, and binary/text I/O and memory-mapping facilities. Project overview
Recommended Free Tools
When can FastUtil help?
Consider it when a program holds or processes many primitive values and collection overhead is relevant to its memory use or performance. Common examples include integer IDs, counters, graph edges, and dense numeric indexes. The potential benefit depends on the collection size, access patterns, data distribution, and how much of the application can use specialized APIs without repeated conversion.
- Potential fit: large primitive-heavy collections, especially when profiling points to allocation, memory footprint, or collection operations as a meaningful cost.
- Less compelling: small collections, code dominated by other work, or APIs that frequently convert between primitive-specialized and object-based types.
- Keep the JDK collection: when its simpler, familiar API is adequate and measurements show no material problem to solve.
Is FastUtil faster or smaller than Java collections?
There is no reliable universal speed or memory-saving percentage to apply to every program. FastUtil’s own guidance notes that library implementations excel in different scenarios and recommends testing in the application where they will run. Hash-based performance also depends strongly on collision-chain length; the project advises setting the load factor explicitly. FastUtil project guidance
Rank #2
A published benchmark project compares FastUtil 8.5.12 with HPPC 0.9.1, Eclipse Collections 11.1.0, and another primitive-collections library using JMH 1.35 on JDK 17.0.2. It varies collection sizes and operations including add/put, contains, iteration, remove, clone, and get. Those results are specific to the test machines, JVM and benchmark setup; they are not a general prediction for another application. Primitive-Collections-Benchmarks
Benchmark the work your program does
Use JMH with representative input sizes and data distributions. Include the operations your application actually performs—such as insertion, lookup, iteration, and removal—and compare the same workload and expected results across implementations. Record the JVM version, warmup, forks, collection sizing, and hash load factor. Measure allocation and observe garbage collection as well as elapsed time; a throughput result alone may miss an important memory trade-off.
Which FastUtil collection should you choose?
Match the specialized type to the primitive in your workload and the operation you need. For instance, an integer-keyed map is a natural candidate for integer IDs mapped to values, while a primitive integer list fits a sequence of numeric values. Check the chosen class’s API and supported interfaces before migrating: specialized methods can differ from the generic collection calls used in existing code.
- For key-value lookups, select a type-specific map matching the key type and value type.
- For unique primitive values, select a matching type-specific set.
- For ordered sequences, consider a specialized list and verify iteration and conversion needs.
- For queueing or priority-based processing, choose the corresponding type-specific queue or priority queue.
Also decide whether you need insertion order, sorted order, concurrency, or compatibility with APIs that accept standard collection interfaces. Do not assume every specialized class has identical ordering or concurrency behavior to a JDK implementation; confirm the contract of the particular class you plan to use.
Rank #4
How to add FastUtil to a Java project
The Maven Central record identified in the available project information lists the core artifact as it.unimi.dsi:fastutil-core:8.5.18. fastutil-core on Maven Central
Maven
Add this dependency inside the project’s <dependencies> element:
Best Value
<dependency>
<groupId>it.unimi.dsi</groupId>
<artifactId>fastutil-core</artifactId>
<version>8.5.18</version>
</dependency>Gradle
For a Gradle project using the standard dependency configuration syntax, add:
dependencies {
implementation("it.unimi.dsi:fastutil-core:8.5.18")
}FastUtil also has a full distribution. Choose between the full artifact and fastutil-core based on which APIs your application needs and the dependency size you are willing to include; check the project’s current packaging information before selecting an artifact. FastUtil repository
Quick Recap
What to check before migrating
- Expected size: if the collection can become very large, initialize it appropriately rather than relying on repeated resizing.
- Hash behavior: set and record the load factor for hash-based collections, and account for the effect of collisions.
- API boundaries: identify conversions or boxing where specialized data moves into generic APIs; those boundaries can reduce the benefit.
- Semantics: verify iteration order, null handling, concurrency requirements and compatibility with callers for the exact implementation you choose.
- Maintenance: confirm the artifact and version policy appropriate for your project, and evaluate upgrades against your supported Java environment.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
