Eclipse Collections

- Features, die du möchtest, mit Collections, die du brauchst -


Einführung in die
Eclipse Collections

Eclipse Collections ist das beste Java Collections Framework, um Freude in die Java Entwicklung zu bringen.

Integriere es heute noch in deinen Source Code mit deinem favorisierten Build-Tool!

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

<dependency>
  <groupId>org.eclipse.collections</groupId>
  <artifactId>eclipse-collections</artifactId>
  <version>10.0.0</version>
</dependency>
compile 'org.eclipse.collections:eclipse-collections-api:10.0.0'
compile 'org.eclipse.collections:eclipse-collections:10.0.0'
<dependency org="org.eclipse.collections" name="eclipse-collections-api" rev="10.0.0" />
<dependency org="org.eclipse.collections" name="eclipse-collections" rev="10.0.0" />

Umfangreiche, saubere und lesbare APIs

Maximiere die Möglichkeiten von Java 8 Lambda Expressions und Methoden Referenzen durch die umfangreichen APIs der Eclipse Collections.

boolean anyPeopleHaveCats =
  this.people
    .anySatisfyWith(Person::hasPet, PetType.CAT);

int countPeopleWithCats =
  this.people
    .countWith(Person::hasPet, PetType.CAT);

MutableList<Person> peopleWithCats =
  this.people
    .selectWith(Person::hasPet, PetType.CAT)
boolean anyPeopleHaveCats =
  this.people
    .anySatisfy(person -> person.hasPet(PetType.CAT));

int countPeopleWithCats =
  this.people
    .count(person -> person.hasPet(PetType.CAT));

MutableList<Person> peopleWithCats =
  this.people
    .select(person -> person.hasPet(PetType.CAT));
boolean anyPeopleHaveCats =
  this.people
    .stream()
    .anyMatch(person -> person.hasPet(PetType.CAT));

long countPeopleWithCats =
  this.people
    .stream()
    .filter(person -> person.hasPet(PetType.CAT))
    .count();

List<Person> peopleWithCats =
  this.people
    .stream()
    .filter(person -> person.hasPet(PetType.CAT))
    .collect(Collectors.toList());

Enthält umfangreiche Strukturen:
Unveränderliche Collections, Primitive Collections, BiMaps, MultiMaps und Bags

Nutze verschiedenste Daten-Container mit nützlichen Factory-Methoden zur Erzeugung.

//Initialisierung von Listen mit den empty(), of(), with() Methoden
MutableList<String> mutableListEmpty =
  Lists.mutable.empty();
MutableList<String> mutableListOf =
  Lists.mutable.of("One", "One", "Two", "Three");
MutableList<String> mutableListWith =
  Lists.mutable.with("One", "One", "Two", "Three");

//Verschiedenste Container-Typen verfügbar
MutableSet<String> mutableSet =
  Sets.mutable.with("One", "One", "Two", "Three");
MutableBag<String> mutableBag =
  Bags.mutable.with("One", "One", "Two", "Three");
MutableStack<String> mutableStack =
  Stacks.mutable.with("One", "One", "Two", "Three");
MutableMap<String, String> mutableMap =
  Maps.mutable.with("key1", "value1", "key2", "value2", "key3", "value3");
MutableMultimap<String, String> multimapWithList =
  Multimaps.mutable.list.with("key1", "value1-1", "key1", "value1-2", "key2","value2-1");
MutableBiMap<String, String> mutableBiMap =
  BiMaps.mutable.with("key1", "value1", "key2", "value2", "key3", "value3");
//Initialisierung von unveränderlichen Listen mit den empty(), of(), with() Methoden
ImmutableList<String> immutableListEmpty =
  Lists.immutable.empty();
ImmutableList<String> immutableListOf =
  Lists.immutable.of("One", "One", "Two", "Three");
ImmutableList<String> immutableListWith =
  Lists.immutable.with("One", "One", "Two", "Three");

//Verschiedenste Kontainertypen verfügbar
ImmutableSet<String> immutableSet =
  Sets.immutable.with("One", "One", "Two", "Three");
ImmutableBag<String> immutableBag =
  Bags.immutable.with("One", "One", "Two", "Three");
ImmutableStack<String> immutableStack =
  Stacks.immutable.with("One", "One", "Two", "Three");
ImmutableMap<String, String> immutableMap =
  Maps.immutable.with("key1", "value1", "key2", "value2", "key3", "value3");
ImmutableMultimap<String, String> immutableMultimapWithList =
  Multimaps.immutable.list.with("key1", "value1-1", "key1", "value1-2", "key2","value2-1");
ImmutableBiMap<String, String> immutableBiMap =
  BiMaps.immutable.with("key1", "value1", "key2", "value2", "key3", "value3");
//Veränderliche und unveränderliche Listen, Sets, Bags, Stacks und Maps
//sind verfügbar für alle 8 primitiven Datentypen
MutableIntList intList =
  IntLists.mutable.of(1, 2, 3);
MutableLongList longList =
  LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList =
  CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList =
  ShortLists.mutable.of((short)1, (short)2, (short)3);
MutableByteList byteList =
  ByteLists.mutable.of((byte)1, (byte)2, (byte)3);
MutableBooleanList booleanList =
  BooleanLists.mutable.of(true, false);
MutableFloatList floatList =
  FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList =
  DoubleLists.mutable.of(1.0, 2.0, 3.0);

//Zahlenreichen können mit IntInterval erstellt werden
IntInterval oneTo10 =
  IntInterval.fromTo(1, 10); // ints von 1 bis 10
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
IntInterval oneTo10By3 =
  IntInterval.fromToBy(1, 10, 3); // ints von 1 bis 10 in 3 Sprüngen
// [1, 4, 7, 10]
IntInterval oddsFrom1To10 =
  IntInterval.oddsFromTo(1, 10); // ungerade ints von 1 bis 10
// [1, 3, 5, 7, 9]
IntInterval evensFrom1To10 =
  IntInterval.evensFromTo(1, 10); // gerade ints von 1 bis 10
// [2, 4, 6, 8, 10]

Reduziert den Speicherverbrauch
mit speichereffizienten Daten-Containern.

Eclipse Collections bietet effiziente Implementierungen von Sets und Maps, sowie Primitive Collections.


Lerne die Eclipse Collections mit Kata

Probiere das Eclipse Collections Kata - die beste Möglichkeit, um die Nutzung der Eclipse Collections zu erlernen. Ein Kata ist eine Serie von fehlschlagenden Unit-Tests. Deine Aufgabe ist es, die Tests mit den Eclipse Collections zu lösen.

@Test
public void getFirstNamesOfAllPeople()
{
  MutableList<Person> people = this.people;
  MutableList<String> firstNames = null; //Ersetze null mit einer Transformation der MutableList.
  MutableList<String> expectedFirstNames =
    Lists.mutable.with("Mary", "Bob", "Ted", "Jake", "Barry", "Terry", "Harry", "John");
  Assert.assertEquals(expectedFirstNames, firstNames);
}
@Test
public void getFirstNamesOfAllPeople()
{
  MutableList<Person> people = this.people;
  MutableList<String> firstNames = people.collect(Person::getFirstName);
  MutableList<String> expectedFirstNames =
    Lists.mutable.with("Mary", "Bob", "Ted", "Jake", "Barry", "Terry", "Harry", "John");
  Assert.assertEquals(expectedFirstNames, firstNames);
}

Geschichte der Eclipse Collections

Die Basis der Eclipse Collections war ein Framework namens Caramel, welches 2004 bei Goldman Sachs entstand. Das Framework entwickelte sich durch aktive Nutzung weiter und wurde 2012 als Open Source Projekt als GitHub Projekt unter dem Namen GS Collections veröffentlicht.

GS Collections wurde danach bei einer Reihe von Konferenzen, inklusive dem JVM Summit 2012 und der JavaOne in 2014, präsentiert. Ein Geschwindigkeitsvergleich zwischen den parallelen Collections von Java 8, Scala und GS Collections wurde auf der QCon New York in 2014 präsentiert. Artikel über die GS Collections (Teil 1 / Teil 2) wurden auch auf InfoQ.com veröffentlicht, welche die Fähigkeiten des Collections Framework durch Beispiele aufzeigen. Weiterhin sind Interviews mit den Entwicklern der GS Collections vorhanden.

Über die Jahre haben sich rund 40 Entwickler an der Entwicklung der Eclipse Collections beteiligt.

Zur Vervollständigung des Open Source Gedankens wurden die GS Collections in 2015 der Eclipse Foundation übertragen und in Eclipse Collections umbenannt. Damit ist das Collections Framework heute komplett Open Source und freut sich auf deine Mithilfe.

Reference Guide

Eine umfassende Anleitung ist auf GitHub verfügbar: Reference Guide.

Source Code

Der Source Code ist auf GitHub verfügbar: Eclipse Collections.