Eclipse Collections

- Características que quieres con las colecciones que necesitas -


Primeros pasos con
Eclipse Collections

Eclipse Collections es el mejor framework de colecciones en Java que trae felicidad a tu desarrollo.

Intégralo a tu código hoy con tus herramientas de construcción favoritas!

<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" />

API enriquecidas, concisas y de fácil lectura

Maximiza el poder de las expresiones Lambda incorporadas en Java desde la versión 8 y los métodos referenciados con APIs enriquecidas disponibles directamente en sus colecciones.

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());

Varios tipos de contenedores de colecciones que incluyen
colecciones inmutables, colecciones primitivas, bimaps, multimaps y bags

Puede hacer uso de varios tipos de contenedores de colecciones, aprovechando métodos factory para la creación de instancias.

//Inicializando listas mutable con los métodos empty(), of(), 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");

//Varios tipos de contenedores de colecciones 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");
//Inicializando listas inmutable con los métodos empty(), of(), 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");

//Varios tipos de contenedores de colecciones 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");
//Mutables e inmutables Lists, Sets, Bags, Stacks y Maps están disponibles para todo los 8 tipos de datos primitivos
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);

//Puede crear un rango de ints con IntInterval
IntInterval oneTo10 =
  IntInterval.fromTo(1, 10); // ints del 1 al 10
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
IntInterval oneTo10By3 =
  IntInterval.fromToBy(1, 10, 3); // ints del 1 al 10 de 3 en 3
// [1, 4, 7, 10]
IntInterval oddsFrom1To10 =
  IntInterval.oddsFromTo(1, 10); //  ints impares del 1 al 10
// [1, 3, 5, 7, 9]
IntInterval evensFrom1To10 =
  IntInterval.evensFromTo(1, 10); // ints pares del 1 al 10
// [2, 4, 6, 8, 10]

Reduce el footprint de memoria
con contenedores de memoria eficientes

Eclipse Collections provee implementaciones de Sets, Maps y Colecciones primitivas con un manejo más eficiente de la memoria.


Aprende Eclipse Collections con Katas

Revisa Eclipse Collections Kata, para aprender el uso idiomático de Eclipse Collections de una manera divertida. Esta kata está configurada como una serie de ejercicios de pruebas unitarias las cuales fallan. Tu tarea es hacer que pasen, usando Eclipse Collections.

@Test
public void getFirstNamesOfAllPeople()
{
  MutableList<Person> people = this.people;
  MutableList<String> firstNames = null; //Reemplace null, con una método de transformación de 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);
}

Historia de Eclipse Collections

El origen de Eclipse Collections empezó con un framework de colecciones llamado Caramel creado en Goldman Sachs en el año 2004. Desde ese momento el framework ha evolucionado, en 2012, fue convertido en proyecto Open Source y publicado en GitHub con el nombre de GS Collections.

GS Collections fue sido presentado en un número de conferencias incluidas el JVM Summit en 2012 y JavaOne en 2014. Un comparativo entre la implementación de paralelismo en Java 8, Scala y GS Collections fue presentada en QCon New York en 2014. También artículos acerca de GS Collections (Part1 / Part2) han sido publicados en InfoQ.com mostrando algunas de las capacidades del framework de colecciones por medio de ejemplos, y entrevistando a los creadores de GS Collections.

A través de estos años, alrededor de 40 desarrolladores contribuyeron con el framework de colecciones.

Para maximizar la mejor naturalidad del proyecto open source, GS Collections fue migrado a la Fundación Eclipse, renombrandolo a Eclipse Collections en 2015. Ahora el framework es completamente abierto a la comunidad y acepta contribuciones!

Guía de referencia

Una guía de referencia de la librería se encuentra disponible en GitHub: Guía de referencia.

Código fuente

El código fuente puede ser consultado en GitHub: Eclipse Collections.