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

SmoothieMap is a Map implementation for Java with the lowest memory usage and absence of rehash latency spikes. Under the hood, it is a version of extendible hashing with 48-slot mini segments. This project also includes a proof-of-concept implementation of SwissTable algorithm in Java.



SmoothieMap - A gulp of low latency Java HashMap

javatuples is one of the simplest java libraries ever made. Its aim is to provide a set of java classes that allow you to work with tuples. 
All tuple classes are: 
<UL>
<li>Typesafe</li><li>Immutable</li><li>Iterable</li><li>Serializable</li><li>Comparable (implements <tt>Comparable&lt;Tuple</tt>&gt;)</li><li>Implementing <tt>equals(...)</tt> and <tt>hashCode()</tt></li><li>Implementing <tt>toString()</tt>
</UL>

javatuples is one of the simplest java libraries ever made. Its aim is to provide a set of java classes that allow you to work with tuples.

javatuples - Typesafe representation of tuples in Java.

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