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

# 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>11.0.0</version>
    </dependency>

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

    implementation 'org.eclipse.collections:eclipse-collections-api:11.0.0'
    implementation 'org.eclipse.collections:eclipse-collections:11.0.0'

    <dependency org="org.eclipse.collections" name="eclipse-collections-api" rev="11.0.0" />
    <dependency org="org.eclipse.collections" name="eclipse-collections" rev="11.0.0" />

    eclipse-collections-api-11.0.0.jar
    eclipse-collections-11.0.0.jar

## 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.

### Contribute

Wir freuen uns auf deine Mithilfe!
Die Eclipse Collections Projekt Roadmap kann hier gefunden werden.
Beiträge können als Pull Request auf GitHub eingereicht werden. Eine Anleitung ist unter How To Contribute verfügbar.

### Letzte Versionen

Eclipse Collections 11.0.0 released (Nov 23rd 2021)

Eclipse Collections 10.4.0 released (Aug 20th 2020)

Eclipse Collections 10.3.0 released (Aug 8th 2020)

Eclipse Collections 10.2.0 released (Feb 11th 2020)

Eclipse Collections 10.1.0 released (Dec 4th 2019)

Eclipse Collections 10.0.0 released (Jul 10th 2019)

### Community Links

Eclipse PMI: eclipse project management infrastructure

GitHub: eclipse-collections

Issues: GitHub issues

Mailing lists: collections-dev mailing list

Wiki: GitHub wiki

Forum: Eclipse Collections Forum

StackOverflow: tag with eclipse-collections

### - Mehr Features, weniger Verlust -