Eclipse Collections - Fonctionnalités dont vous rêvez avec les collections dont vous avez besoin.

# Eclipse Collections

### - Fonctionnalités dont vous rêvez avec les collections dont vous avez besoin -

## Premiers pas avec les
Eclipse Collections

Eclipse Collections est la meilleure librairie Java de Collections. Elle va dynamiser tous vos projets Java.
Utilisez la dans vos projets dès aujourd'hui avec vos outils de développement favoris!

    <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

## Une API claire, riche et concise.

Multipliez la puissance des expressions lambda de Java 8 avec une API complète directement utilisable pour vos 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());

## De nombreux types de conteneurs, incluant les collections immuables et non-immuables, les collections primitives, les ensembles et les multiensembles

Utilisez les nombreux types de conteneurs existants, en vous appuyant sur les méthodes d'instanciation faciles présentes dans les factories .

    //Initialisation d'une liste non-immuable avec les méthodes empty(), of() et with()
    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");

    //De nombreux types de conteneurs sont disponibles
    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");

    //Initialisation d'une liste immuable avec les méthodes empty(), of() et with()
    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");

    //De nombreux types de conteneurs sont disponibles
    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");

    //Listes (List) immuables ou non-immuables, Ensembles (Sets), Multiensemble (Bags), Piles (Stacks) et Tableaux associatifs (Maps) sont utilisables avec les 8 types primitifs
    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);

    //Vous pouvez créer une liste d'entier avec IntInterval
    IntInterval oneTo10 =
      IntInterval.fromTo(1, 10); // entiers de 1 à 10
    // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    IntInterval oneTo10By3 =
      IntInterval.fromToBy(1, 10, 3); // entier de 1 à 10 avec un incrément de 3
    // [1, 4, 7, 10]
    IntInterval oddsFrom1To10 =
      IntInterval.oddsFromTo(1, 10); // nombres impairs de 1 à 10
    // [1, 3, 5, 7, 9]
    IntInterval evensFrom1To10 =
      IntInterval.evensFromTo(1, 10); // nombres pairs de 1 à 10
    // [2, 4, 6, 8, 10]

## Reduisez votre utilisation de la mémoire
avec des conteneurs optimisés

Eclipse Collections vous fournit une implémentation optimisée pour vos ensembles (Sets) et vos tableaux associatifs (Maps), ainsi que vos collections primitives.

## Apprendre les Eclipse Collections avec un Kata

Faites un tour sur les Eclipse Collections Kata, une facon simple et amusante de découvrir le monde des Eclipse Collections. Ces kata ont été concu avec des tests unitaires défaillants. Votre objectif est de les faire réussir, en utilisant les Eclipse Collections.

    @Test
    public void getFirstNamesOfAllPeople()
    {
      MutableList<Person> people = this.people;
      MutableList<String> firstNames = null; //Remplacez null par une méthode sur 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);
    }

## Origine des Eclipse Collections

Les premières versions des Eclipse Collections ont été crée en tant qu'une librairie de collections nommée Caramel à Goldman Sachs en 2004. Depuis, la plateforme a évolué, et en 2012, elle a été partagé sur Github sous le nom de GS Collections.
GS Collections a été présente durant plusieurs évènements incluant le JVM Summit de 2012 et JavaOne de 2014. Une comparaison des performances entre les implemtations des évaluations paresseuses de Java 8, Scala et de GS a été présenté au QCon New York en 2014. Aussi, un article sur les GS Collections (Partie 1 / Partie 2) a éte publié sur InfoQ.com montrant les capacités de cette librairie à travers des exemples et des interviews des créateurs des GS Collections.
Au fil des années, environ 40 developpeurs provenant de la même société ont contribué à cette librairie.
Pour permettre une meilleure utilisation de la communauté Open Source, GS Collections a été migré dans la Fondation Eclipse et re-nommé en Eclipse Collections en 2015. Maintenant, la librairie est totalement ouverte vers la communauté, n'attendant plus que votre contribution!

## Guide de référence

Un guide complet de référence sur la librairie est accessible sur GitHub: Guide de Référence (en Anglais).

## Code Source

Le code source est accessible sur GitHub: Eclipse Collections.

### Contribuer

Tout contributeur est le bienvenu !
Le futur des Eclipse Collections est accessible ici.
Pour contribuer, il vous suffit juste de faire un pull request sur GitHub. La section Contribuer est le meilleur moyen de commencer.

### Versions les plus récentes

Eclipse Collections 11.0.0 delivré le (Nov 23 2021)

Eclipse Collections 10.4.0 delivré le (Aug 20 2020)

Eclipse Collections 10.3.0 delivré le (Aug 8 2020)

Eclipse Collections 10.2.0 delivré le (Feb 11 2020)

Eclipse Collections 10.1.0 delivré le (Dec 4 2019)

Eclipse Collections 10.0.0 delivré le (Juil 10 2019)

### Liens

Eclipse PMI: Infraestrutura de gerenciamento de projetos Eclipse

GitHub: eclipse-collections

Issues: GitHub issues

Liste de diffusion: collections-dev

Wiki: GitHub wiki

Forum: Eclipse Collections Forum

StackOverflow: taggez avec eclipse-collections

### - Plus de fonctionnalités, moins de soucis -