PCollections

General

Category
Free
Tag
Data Structures
License
MIT License
Registered
Jun 30, 2015
Favorites
0
Link
https://github.com/blackdrag/pcollections
See also
rtree
gs-collections
rxlist
Agrona
SparseBuilders

Additional

Language
Java
Version
v2.1.2 (Oct 12, 2011)
Created
Mar 20, 2014
Updated
Feb 6, 2024
Owner
harold (hrldcpr)
Contributors
Liam Miller-Cushon (cushon)
ilya-g
Jochen Theodorou (blackdrag)
Mike Klein (mtklein)
harold (hrldcpr)
Shantanu Kumar (kumarshantanu)
Johnny Lim (izeye)
glebfrank
Günther Grill (guenhter)
valery1707
Oleg Osipenko (olegosipenko)
Manu Sridharan (msridhar)
Mark Perry (mperry)
puntogil
Jirka Kremser (jkremser)
Patrick Doyle (prdoyle)
Callum Seabrook (BomBardyGamer)
Ran Ari-Gur (ran-arigur)
Show all (19)19
Activity
Badge
Generate
Download
Source code

PCollections

A Persistent Java Collections Library

Overview

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.

Persistent and immutable datatypes are increasingly appreciated as a simple, design-friendly, concurrency-friendly, and sometimes more time- and space-efficient alternative to mutable datatypes.

Persistent versus Unmodifiable

Note that these immutable collections are very different from the immutable collections returned by Java's Collections.unmodifiableCollection() and similar methods. The difference is that Java's unmodifiable collections have no producers, whereas PCollections have very efficient producers.

Thus if you have an unmodifiable Collection x and you want a new Collection x2 consisting of the elements of x in addition to some element e, you would have to do something like:

Collection x2 = new HashSet(x);
x2.add(e);

which involves copying all of x, using linear time and space.

If, on the other hand, you have a PCollection y you can simply say:

PCollection y2 = y.plus(e);

which still leaves y untouched but generally requires little or no copying, using time and space much more efficiently.

Usage

PCollections are created using producers and static factory methods. Some example static factory methods are HashTreePSet.empty() which returns an empty PSet, while HashTreePSet.singleton(e) returns a PSet containing just the element e, and HashTreePSet.from(collection) returns a PSet containing the same elements as collection. See Example Code below for an example of using producers.

The same empty(), singleton(), and from() factory methods are found in each of the PCollections implementations, which currently include one concrete implementation for each abstract type:

PCollections are highly interoperable with Java Collections:

  • Every PCollection is a java.util.Collection.
  • Every PMap is a java.util.Map.
  • Every PSequence is a java.util.List.
    • This includes every PStack and every PVector.
  • Every PSet is a java.util.Set.
  • Every PSortedMap is a java.util.SortedMap and java.util.NavigableMap.
  • Every PSortedSet is a java.util.SortedSet and java.util.NavigableSet.

PCollections uses Semantic Versioning, which establishes a strong correspondence between API changes and version numbering.

PCollections is in the Maven Central repository, under org.pcollections. Thus the Maven coordinates for PCollections are:

<dependency>
    <groupId>org.pcollections</groupId>
    <artifactId>pcollections</artifactId>
    <version>4.0.1</version>
</dependency>

or Gradle:

compile 'org.pcollections:pcollections:4.0.1'

Example Code

The following gives a very simple example of using PCollections, including the static factory method HashTreePSet.empty() and the producer plus(e):

import org.pcollections.*;

public class Example {
  public static void main(String... args) {
    PSet<String> set = HashTreePSet.empty();
    set = set.plus("something");

    System.out.println(set);
    System.out.println(set.plus("something else"));
    System.out.println(set);
  }
}

Running this program gives the following output:

[something]
[something else, something]
[something]

Building from source

To build the project from source clone the repository and then run ./gradlew

Related Work

Clojure, Scala, and kotlinx.collections.immutable also provide persistent collections on the JVM, but they are less interoperable with Java. Both Guava and java.util.Collections provide immutable collections but they are not persistent—that is, they do not provide efficient producers—so they are not nearly as useful. See Persistent versus Unmodifiable above.