Immutable data cannot be changed once created, leading to much simpler application development, no defensive copying, and enabling advanced memoization and change detection techniques with simple logic. Persistent data presents a mutative API which does not update the data in-place, but instead always yields new updated data. Immutable.js provides many Persistent Immutable data structures including: List, Stack, Map, OrderedMap, Set, OrderedSet and Record.
 
Immutable.js has no dependencies, which makes it predictable to include in a Browser. Immutable.js is inspired by Clojure, Scala, Haskell and other functional programming environments, it's designed to bring these powerful concepts to JavaScript, and therefore has an Object-Oriented API that closely mirrors that of ES2015 Array, Map, and Set.

Immutable data cannot be changed once created, leading to much simpler application development, no defensive copying, and enabling advanced memoization and change detection techniques with simple logic. Persistent data presents a mutative API which does not update the data in-place, but instead always yields new updated data. Immutable.js provides many Persistent Immutable data structures including: List, Stack, Map, OrderedMap, Set, OrderedSet and Record.

Immutable.js - Immutable collections for JavaScript

Java Concurrency Tools for the JVM. This project aims to offer some concurrent data structures currently missing from the JDK.
 
<ul>
<li>
SPSC/MPSC/SPMC/MPMC variations for concurrent queues:
<ul>
<li>SPSC - Single Producer Single Consumer (Wait Free, bounded and unbounded)</li>
<li>MPSC - Multi Producer Single Consumer (Lock less, bounded and unbounded)</li>
<li>SPMC - Single Producer Multi Consumer (Lock less, bounded)</li>
<li>MPMC - Multi Producer Multi Consumer (Lock less, bounded)</li>
</ul>
</li>
<li>
SPSC/MPSC linked array queues offer a balance between performance, allocation and footprint
</li>
<li>
An expanded queue interface (MessagePassingQueue):
<ul>
<li>relaxedOffer/Peek/Poll: trade off conflated guarantee on full/empty queue state with improved performance.</li>
<li>drain/fill: batch read and write methods for increased throughput and reduced contention</li>
</ul>
</li>
</ul>

Java Concurrency Tools for the JVM. This project aims to offer some concurrent data structures currently missing from the JDK.

JCTools - Java Concurrency Tools for the JVM

Eclipse Collections is a collections framework for Java. It has JDK-compatible List, Set and Map implementations with a rich API, additional types not found in the JDK like Bags, Multimaps, and set of utility classes that work with any JDK compatible Collections, Arrays, Maps, or Strings. The iteration protocol was inspired by the Smalltalk collection framework. It maximizes the power of Java 8 Lambda expressions and method references with rich APIs directly available on your collections. 

Eclipse Collections - Best Java Collection Framework 

Agrona provides a library of data structures and utility methods that are a common need when building high-performance applications in Java and C++. It supports Buffers, Map, Sets, Cache, Queues and lot more.
<ul>
<li>Buffers - Thread safe direct and atomic for working with on and off heap memory with memory ordering semantics.</li>
<li>Lists - Array backed lists of int/long primitives to avoid boxing.</li>
<li>Maps - Open addressing and linear probing with int/long primitive keys to object reference values.</li>
<li>Maps - Open addressing and linear probing with int/long primitive keys to int/long values.</li>
<li>Sets - Open addressing and linear probing for int/long primitives and object references.</li>
<li>Cache - Set Associative with int/long primitive keys to object reference values.</li>
<li>Clocks - Clock implementations to abstract system clocks, allow caching, and enable testing.</li>
<li>Queues - Lock-less implementations for low-latency applications.</li>
<li>Ring/Broadcast Buffers - implemented off-heap for IPC communication.</li>
<li>Basic Agent framework.</li>
<li>Signal handling to support "Ctrl + c" in a server application.</li>
<li>Scalable Timer Wheel.</li>
<li>Basic code generation from annotated implementations that can vary on primitive types.</li>
<li>Off-heap counters implementation for application telemetry and position tracking.</li>
<li>Implementations of InputStream and OutputStream that can wrap direct buffers.</li>
<li>DistinctErrorLog: A log of distinct errors to avoid filling disks with existing logging approaches.</li>
</ul>

Agrona provides a library of data structures and utility methods that are a common need when building high-performance applications in Java and C++. It supports Buffers, Map, Sets, Cache, Queues and lot more.

Agrona - Library to build high-performance applications in Java and C++

Goque provides embedded, disk-based implementations of stack and queue data structures. Motivation for creating this project was the need for a persistent priority queue that remained performant while growing well beyond the available memory of a given machine. While there are many packages for Go offering queues, they all seem to be memory based and/or standalone solutions that are not embeddable within an application.

goque - Persistent stacks and queues for Go backed by LevelDB

A lightning fast, transactional, file-based FIFO for Android and Java. QueueFile is a lightning-fast, transactional, file-based FIFO. Addition and removal from an instance is an O(1) operation and is atomic. Writes are synchronous; data will be written to disk before an operation returns. The underlying file is structured to survive process and even system crashes and if an I/O exception is thrown during a mutating change, the change is aborted.

Tape - A lightning fast, transactional, file-based FIFO for Android and Java.

The main goal of Boon is to reduce the productivity delta between Java and Python/Groovy/Ruby. The idea is to just create a lower ceremony APIs. Less Java like APIs, and more getting things done quickly APIs. If reading a file takes one line of code in Ruby/Python/Groovy, then it will also in Java. If slice notation is part of those language, then Boon will have it to.
 
Boon helps to make lists, maps, and sets feel like they are part of the core language instead of APIs. This includes mimicking map literals, list literals, and set literals. Boon will have its own collection libs. Boon has a collection query language already. It is good alternative to Guava.

The main goal of Boon is to reduce the productivity delta between Java and Python/Groovy/Ruby. The idea is to just create a lower ceremony APIs. Less Java like APIs, and more getting things done quickly APIs. If reading a file takes one line of code in Ruby/Python/Groovy, then it will also in Java. If slice notation is part of those language, then Boon will have it to.



Boon - Low Ceremony. High Productivity. A real boon to Java to developers!

This library provides high-quality Java implementations of mutable and immutable data structures, each sharing a common API. Rather than using the existing collection interfaces in java.util such as List or Map, it provides its own interfaces (IList, IMap, ISet) that provide functional semantics - each update to a collection returns a reference to a new collection. 

bifurcan - impure functional data structures

A Persistent Java Collections Library. PCollections serves as a persistent and immutable analogue of the Java Collections Framework. This includes efficient, thread-safe, generic, immutable, and persistent stacks, maps, vectors, sets, and bags, compatible with their Java Collections counterparts.

PCollections - A Persistent Java Collections Library

Judy is a general purpose dynamic array implemented as a C callable library. Judy's speed and memory usage are typically better than other data storage models and improves with very large data sets. Judy's key benefits are scalability, high performance, and memory efficiency. A Judy array is extensible and can scale up to a very large number of elements, bounded only by machine memory. Since Judy is designed as an unbounded array, the size of a Judy array is not pre-allocated but grows and shrinks dynamically with the array population. 
 
 Judy can replace many common data structures, such as arrays, sparse arrays, hash tables, B-trees, binary trees, linear lists, skiplists, other sort and search algorithms, and counting functions.

Judy is a general purpose dynamic array implemented as a C callable library. Judy's speed and memory usage are typically better than other data storage models and improves with very large data sets.  Judy's key benefits are scalability, high performance, and memory efficiency. A Judy array is extensible and can scale up to a very large number of elements, bounded only by machine memory. Since Judy is designed as an unbounded array, the size of a Judy array is not pre-allocated but grows and shrinks dynamically with the array population. 

Judy - General purpose dynamic array

A library for managing large off-heap arrays that can hold more than 2G (2^31) entries in Java and Scala. Notably LArray is disposable by calling LArray.free or you can let GC automatically release the memory. LArray also can be used to create an mmap (memory-mapped file) whose size is more than 2GB

LArray - Large off-heap arrays for Java/Scala

Capsule aims to become a full-fledged (immutable) collections library for Java 8+ that is solely built around persistent tries. The library is designed for standalone use and for being embedded in domain-specific languages. Capsule still has to undergo some incubation before it can ship as a well-rounded collection library. Nevertheless, the code is stable and performance is solid.
 
The standard libraries of recent Java Virtual Machine languages, such as Clojure or Scala, contain scalable and well-performing immutable collection data structures that are implemented as Hash-Array Mapped Tries (HAMTs). HAMTs already feature efficient lookup, insert, and delete operations, however due to their tree-based nature their memory footprints and the runtime performance of iteration and equality checking lag behind array-based counterparts.
 
We introduce CHAMP (Compressed Hash-Array Mapped Prefix-tree), an evolutionary improvement over HAMTs. The new design increases the overall performance of immutable sets and maps. Furthermore, its resulting general purpose design increases cache locality and features a canonical representation.

Capsule aims to become a full-fledged (immutable) collections library for Java 8+ that is solely built around persistent tries. The library is designed for standalone use and for being embedded in domain-specific languages. Capsule still has to undergo some incubation before it can ship as a well-rounded collection library. Nevertheless, the code is stable and performance is solid.

Capsule - The Capsule Hash Trie Collections Library

A big, fast and persistent queue based on memory mapped file.
 
Features include: 
<ol>
<li>Fast: close to the speed of direct memory access, both enqueue and dequeue are close to O(1) memory access.</li>
<li>Big: the total size of the queue is only limited by the available disk space.</li>
<li>Persistent: all data in the queue is persisted on disk, and is crash resistant.</li>
<li>Reliable: OS will be responsible to presist the produced messages even your process crashes.</li>
<li>Realtime: messages produced by producer threads will be immediately visible to consumer threads.</li>
<li>Memory-efficient: automatic paging &amp; swapping algorithm, only most-recently accessed data is kept in memory.</li>
<li>Thread-safe: multiple threads can concurrently enqueue and dequeue without data corruption.</li>
<li>Simple&amp;Light-weight: current number of source files is 12 and the library jar is less than 30K.</li>
</ol>

A big, fast and persistent queue based on memory mapped file.

Big Queue - A big, fast and persistent queue based on memory mapped file.

Cactoos is a collection of object-oriented Java primitives as an alternative to Google Guava and Apache Commons.

Cactoos - Object-Oriented Java primitives, as an alternative to Google Guava and Apache Commons

Immutable Clojure collections and a Transformation abstraction for Java 8+, immutably, type-safely, and with good performance. It provide support for RRB Tree, which is an immutable List (like Clojure's PersistentVector) that also supports random inserts, deletes, and can be split and joined back together in logarithmic time.

Paguro - Immutable Collections and Functional Transformations for the JVM

Discover open source projects across all platforms

Projects