Skip to content
The Eclipse Collections Project
Branch: master
Clone or download
Pull request Compare This branch is 1 commit ahead of eclipse:master.
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.idea
.mvn
acceptance-tests
artwork
docs
eclipse-collections-api
eclipse-collections-code-generator-maven-plugin
eclipse-collections-code-generator
eclipse-collections-forkjoin
eclipse-collections-testutils
eclipse-collections
jcstress-tests
jmh-scala-tests
jmh-tests
junit-trait-runner
missing-dependency
p2-feature
p2-repository
performance-tests
scala-unit-tests
serialization-tests
site
test-coverage
unit-tests-java8
unit-tests
.gitattributes
.gitignore
.travis-command-ea-builds.sh
.travis.yml
CONTRIBUTING.md
LICENSE-EDL-1.0.txt
LICENSE-EPL-1.0.txt
README.md
RELEASE_NOTE_DRAFT.md
about.html
checkstyle-configuration.xml
checkstyle-suppressions.xml
deploy.properties
eclipse-collections-parent.iml
findbugs-exclude.xml
java.header
pom-template
pom.xml
version.properties

README.md

English | 中文 | Deutsch | Français | 日本語 | Português-Brasil | Русский

Eclipse Collections is a comprehensive collections library for Java. The library enables productivity and performance by delivering an expressive and efficient set of APIs and types. The iteration protocol was inspired by the Smalltalk collection framework, and the collections are compatible with the Java Collection Framework types.

Why Eclipse Collections?

  • Productivity
    • Rich, functional, and fluent APIs with great symmetry
    • List, Set, Bag, Stack, Map, Multimap, BiMap, Interval Types
    • Readable, Mutable, and Immutable Types
    • Mutable and Immutable Collection Factories
    • Adapters and Utility classes for JCF Types
  • Performance
    • Memory Efficient Containers
    • Optimized Eager, Lazy and Parallel APIs
    • Primitive Collections for all primitive types
  • Actively developed since 2005

Learn Eclipse Collections

Acquiring Eclipse Collections

Maven

<dependency>
  <groupId>org.eclipse.collections</groupId>
  <artifactId>eclipse-collections-api</artifactId>
  <version>9.2.0</version>
</dependency>

<dependency>
  <groupId>org.eclipse.collections</groupId>
  <artifactId>eclipse-collections</artifactId>
  <version>9.2.0</version>
</dependency>

Gradle

compile 'org.eclipse.collections:eclipse-collections-api:9.2.0'
compile 'org.eclipse.collections:eclipse-collections:9.2.0'

OSGi Bundle

Eclipse software repository location: http://download.eclipse.org/collections/9.2.0/repository

Some Quick Examples

Eclipse Collections puts iteration methods directly on the container types. Here's several code examples that demonstrate the simple and flexible style of programming with Eclipse Collections.

First, we will define a simple class named Person to hold the first and last names of three people.

public class Person
{
    private final String firstName;
    private final String lastName;

    public Person(String firstName, String lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    ...
    public String getLastName()
    {
        return this.lastName;
    }
    
    public boolean lastNameEquals(String name)
    {
        return name.equals(this.lastName);
    }
}

Collect (aka map, transform)

Now we will create a MutableList with three instances of the Person class. Then we will collect their last names into a new MutableList, and finally output the names to a comma delimited String using makeString.

MutableList<Person> people = Lists.mutable.with(
        new Person("Sally", "Smith"),
        new Person("Ted", "Watson"),
        new Person("Mary", "Williams"));
MutableList<String> lastNames = people.collect(person -> person.getLastName());
Assert.assertEquals("Smith, Watson, Williams", lastNames.makeString());

The lambda in the example above can also be replaced with a method reference.

MutableList<String> lastNames = people.collect(Person::getLastName);

Eclipse Collections has support for both Mutable and Immutable collections, and the return types of methods are covariant. While the collect method on a MutableList returned a MutableList, the collect method on an ImmutableList will return an ImmutableList. Here we use the same Lists factory to create an ImmutableList.

ImmutableList<Person> people = Lists.immutable.with(
        new Person("Sally", "Smith"),
        new Person("Ted", "Watson"),
        new Person("Mary", "Williams"));
ImmutableList<String> lastNames = people.collect(Person::getLastName);
Assert.assertEquals("Smith, Watson, Williams", lastNames.makeString());

Eclipse Collections has a lazy API as well, which is available by calling the method asLazy. The method collect will now return a LazyIterable. The LazyIterable that is returned does not evaluate anything until the call to a terminal method is made. In this case, the call to makeString will force the LazyIterable to collect the last names.

LazyIterable<String> lastNames = people.asLazy().collect(Person::getLastName);
Assert.assertEquals("Smith, Watson, Williams", lastNames.makeString());

Select / Reject (aka filter / filter not)

We can find all of the people with the last name "Smith" using the method named select.

MutableList<Person> people = Lists.mutable.with(
        new Person("Sally", "Smith"),
        new Person("Ted", "Watson"),
        new Person("Mary", "Williams"));
MutableList<Person> smiths = people.select(person -> person.lastNameEquals("Smith"));
Assert.assertEquals("Smith", smiths.collect(Person::getLastName).makeString());

If we want to use a method reference, we can use the method selectWith.

MutableList<Person> smiths = people.selectWith(Person::lastNameEquals, "Smith");
Assert.assertEquals("Smith", smiths.collect(Person::getLastName).makeString());

We can find all the people who do not have a last name of "Smith" using the method named reject.

MutableList<Person> notSmiths = people.reject(person -> person.lastNameEquals("Smith"));
Assert.assertEquals("Watson, Williams", notSmiths.collect(Person::getLastName).makeString());

If we want to use a method reference, we can use the method rejectWith.

MutableList<Person> notSmiths = people.rejectWith(Person::lastNameEquals, "Smith");
Assert.assertEquals("Watson, Williams", notSmiths.collect(Person::getLastName).makeString());

Any / All / None

We can test whether any, all or none of the elements of a collection satisfy a given condition.

// Any
Assert.assertTrue(people.anySatisfy(person -> person.lastNameEquals("Smith"));
Assert.assertTrue(people.anySatisfyWith(Person::lastNameEquals, "Smith"));

// All
Assert.assertFalse(people.allSatisfy(person -> person.lastNameEquals("Smith"));
Assert.assertFalse(people.allSatisfyWith(Person::lastNameEquals, "Smith"));

// None
Assert.assertFalse(people.noneSatisfy(person -> person.lastNameEquals("Smith"));
Assert.assertFalse(people.noneSatisfyWith(Person::lastNameEquals, "Smith"));

How to Contribute

We welcome contributions! We accept contributions via pull requests here in GitHub. Please see How To Contribute to get started.

Additional information

You can’t perform that action at this time.