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.1.0</version> </dependency> <dependency> <groupId>org.eclipse.collections</groupId> <artifactId>eclipse-collections</artifactId> <version>11.1.0</version> </dependency>
implementation 'org.eclipse.collections:eclipse-collections-api:11.1.0' implementation 'org.eclipse.collections:eclipse-collections:11.1.0'
<dependency org="org.eclipse.collections" name="eclipse-collections-api" rev="11.1.0" /> <dependency org="org.eclipse.collections" name="eclipse-collections" rev="11.1.0" />
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());
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]
Eclipse Collections bietet effiziente Implementierungen von Sets und Maps, sowie Primitive Collections.
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); }
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.
Eine umfassende Anleitung ist auf GitHub verfügbar: Reference Guide.
Der Source Code ist auf GitHub verfügbar: Eclipse Collections.