Package org.eclipse.collections.api.map
Interface MapIterable<K,V>
-
- All Superinterfaces:
InternalIterable<V>
,java.lang.Iterable<V>
,RichIterable<V>
- All Known Subinterfaces:
BiMap<K,V>
,ConcurrentMutableMap<K,V>
,FixedSizeMap<K,V>
,ImmutableBiMap<K,V>
,ImmutableMap<K,V>
,ImmutableMapIterable<K,V>
,ImmutableOrderedMap<K,V>
,ImmutableSortedMap<K,V>
,MutableBiMap<K,V>
,MutableMap<K,V>
,MutableMapIterable<K,V>
,MutableOrderedMap<K,V>
,MutableSortedMap<K,V>
,OrderedMap<K,V>
,SortedMapIterable<K,V>
,UnsortedMapIterable<K,V>
- All Known Implementing Classes:
AbstractBiMap
,AbstractImmutableBiMap
,AbstractImmutableBiMap.Inverse
,AbstractImmutableMap
,AbstractImmutableSortedMap
,AbstractMapIterable
,AbstractMemoryEfficientMutableMap
,AbstractMutableBiMap
,AbstractMutableBiMap.Inverse
,AbstractMutableMap
,AbstractMutableMapIterable
,AbstractMutableSortedMap
,AbstractSynchronizedMapIterable
,ConcurrentHashMap
,ConcurrentHashMapUnsafe
,ConcurrentMutableHashMap
,DoubletonMap
,EmptyMap
,HashBiMap
,ImmutableDoubletonMap
,ImmutableEmptyMap
,ImmutableEmptyMapWithHashingStrategy
,ImmutableEmptySortedMap
,ImmutableHashBiMap
,ImmutableQuadrupletonMap
,ImmutableSingletonMap
,ImmutableTreeMap
,ImmutableTripletonMap
,ImmutableUnifiedMap
,ImmutableUnifiedMapWithHashingStrategy
,MapAdapter
,OrderedMapAdapter
,SingletonMap
,SortedMapAdapter
,SynchronizedBiMap
,SynchronizedMutableMap
,SynchronizedSortedMap
,TreeSortedMap
,TripletonMap
,UnifiedMap
,UnifiedMapWithHashingStrategy
,UnmodifiableBiMap
,UnmodifiableMutableMap
,UnmodifiableMutableOrderedMap
,UnmodifiableTreeMap
public interface MapIterable<K,V> extends RichIterable<V>
A Read-only Map API, with the minor exception inherited from java.lang.Iterable. The method map.iterator().remove() will throw an UnsupportedOperationException.
-
-
Method Summary
All Methods Instance Methods Abstract Methods Default Methods Modifier and Type Method Description default <K1,V1,V2>
MapIterable<K1,V2>aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
Applies an aggregate function over the map grouping results into a map based on the specific key and value groupBy functions.<K2,V2>
MapIterable<K2,V2>collect(Function2<? super K,? super V,Pair<K2,V2>> function)
For each key and value of the map the function is evaluated.<R> MapIterable<K,R>
collectValues(Function2<? super K,? super V,? extends R> function)
For each key and value of the map the function is evaluated.boolean
containsKey(java.lang.Object key)
boolean
containsValue(java.lang.Object value)
Pair<K,V>
detect(Predicate2<? super K,? super V> predicate)
Return the first key and value of the map for which the predicate evaluates to true when they are given as arguments.java.util.Optional<Pair<K,V>>
detectOptional(Predicate2<? super K,? super V> predicate)
Return the first key and value of the map as an Optional for which the predicate evaluates to true when they are given as arguments.boolean
equals(java.lang.Object o)
Follows the same general contract asMap.equals(Object)
.Multimap<V,K>
flip()
Given a map from Domain->
Range return a multimap from Range->
Domain.MapIterable<V,K>
flipUniqueValues()
Return the MapIterable that is obtained by flipping the direction of this map and making the associations from value to key.void
forEachKey(Procedure<? super K> procedure)
Calls theprocedure
with each key of the map.void
forEachKeyValue(Procedure2<? super K,? super V> procedure)
Calls theprocedure
with each key-value pair of the map.void
forEachValue(Procedure<? super V> procedure)
Calls the procedure with each value of the map.V
get(java.lang.Object key)
V
getIfAbsent(K key, Function0<? extends V> function)
Return the value in the Map that corresponds to the specified key, or if there is no value at the key, return the result of evaluating the specified Function0.V
getIfAbsentValue(K key, V value)
Return the value in the Map that corresponds to the specified key, or if there is no value at the key, returnvalue
.<P> V
getIfAbsentWith(K key, Function<? super P,? extends V> function, P parameter)
Return the value in the Map that corresponds to the specified key, or if there is no value at the key, return the result of evaluating the specified function and parameter.default V
getOrDefault(java.lang.Object key, V defaultValue)
int
hashCode()
Follows the same general contract asMap.hashCode()
.<A> A
ifPresentApply(K key, Function<? super V,? extends A> function)
If there is a value in the Map that corresponds to the specified key return the result of applying the specified Function on the value, otherwise return null.default <IV> IV
injectIntoKeyValue(IV injectedValue, Function3<? super IV,? super K,? super V,? extends IV> function)
Implements theinjectInto
pattern with each key-value pair of the map.RichIterable<K>
keysView()
Returns an unmodifiable lazy iterable wrapped around the keySet for the map.RichIterable<Pair<K,V>>
keyValuesView()
Returns an unmodifiable lazy iterable of key/value pairs wrapped around the entrySet for the map.default java.util.stream.Stream<V>
parallelStream()
MapIterable<K,V>
reject(Predicate2<? super K,? super V> predicate)
For each key and value of the map the predicate is evaluated, if the result of the evaluation is false, that key and value are returned in a new map.MapIterable<K,V>
select(Predicate2<? super K,? super V> predicate)
For each key and value of the map the predicate is evaluated, if the result of the evaluation is true, that key and value are returned in a new map.default java.util.Spliterator<V>
spliterator()
default java.util.stream.Stream<V>
stream()
MapIterable<K,V>
tap(Procedure<? super V> procedure)
Executes the Procedure for each value of the map and returnsthis
.ImmutableMapIterable<K,V>
toImmutable()
java.lang.String
toString()
Returns a string with the keys and values of this map separated by commas with spaces and enclosed in curly braces.RichIterable<V>
valuesView()
Returns an unmodifiable lazy iterable wrapped around the values for the map.-
Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach, forEachWith, forEachWithIndex
-
Methods inherited from interface org.eclipse.collections.api.RichIterable
aggregateBy, aggregateBy, aggregateInPlaceBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collect, collectBoolean, collectBoolean, collectByte, collectByte, collectChar, collectChar, collectDouble, collectDouble, collectFloat, collectFloat, collectIf, collectIf, collectInt, collectInt, collectLong, collectLong, collectShort, collectShort, collectWith, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, count, countBy, countBy, countByEach, countByEach, countByWith, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, flatCollectWith, forEach, getAny, getFirst, getLast, getOnly, groupBy, groupBy, groupByAndCollect, groupByEach, groupByEach, groupByUniqueKey, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, into, isEmpty, makeString, makeString, makeString, makeString, max, max, maxBy, maxByOptional, maxOptional, maxOptional, min, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, notEmpty, partition, partitionWith, reduce, reduceInPlace, reduceInPlace, reject, reject, rejectWith, rejectWith, select, select, selectInstancesOf, selectWith, selectWith, size, sumByDouble, sumByFloat, sumByInt, sumByLong, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toImmutableBag, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, zip, zip, zipWithIndex, zipWithIndex
-
-
-
-
Method Detail
-
get
V get(java.lang.Object key)
- See Also:
Map.get(Object)
-
containsKey
boolean containsKey(java.lang.Object key)
- See Also:
Map.containsKey(Object)
-
containsValue
boolean containsValue(java.lang.Object value)
- See Also:
Map.containsValue(Object)
-
forEachValue
void forEachValue(Procedure<? super V> procedure)
Calls the procedure with each value of the map.Set<String> result = UnifiedSet.newSet(); MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three", 4, "Four"); map.forEachValue(new CollectionAddProcedure<String>(result)); Verify.assertSetsEqual(UnifiedSet.newSetWith("One", "Two", "Three", "Four"), result);
-
tap
MapIterable<K,V> tap(Procedure<? super V> procedure)
Executes the Procedure for each value of the map and returnsthis
.return peopleByCity.tap(person -> LOGGER.info(person.getName()));
- Specified by:
tap
in interfaceRichIterable<K>
- Since:
- 6.0
- See Also:
RichIterable.forEach(Procedure)
-
forEachKey
void forEachKey(Procedure<? super K> procedure)
Calls theprocedure
with each key of the map.final Collection<Integer> result = new ArrayList<Integer>(); MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "1", 2, "2", 3, "3"); map.forEachKey(new CollectionAddProcedure<Integer>(result)); Verify.assertContainsAll(result, 1, 2, 3);
-
forEachKeyValue
void forEachKeyValue(Procedure2<? super K,? super V> procedure)
Calls theprocedure
with each key-value pair of the map.final Collection<String> collection = new ArrayList<String>(); MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three"); map.forEachKeyValue((Integer key, String value) -> collection.add(String.valueOf(key) + value)); Verify.assertContainsAll(collection, "1One", "2Two", "3Three");
-
injectIntoKeyValue
default <IV> IV injectIntoKeyValue(IV injectedValue, Function3<? super IV,? super K,? super V,? extends IV> function)
Implements theinjectInto
pattern with each key-value pair of the map.MapIterable<Integer, Integer> map1 = Maps.immutable.with(3, 3, 2, 2, 1, 1); Integer sum1 = map1.injectIntoKeyValue(0, (sum, key, value) -> sum + key + value); assertEquals(12, sum1);
- Since:
- 11.1
-
flipUniqueValues
MapIterable<V,K> flipUniqueValues()
Return the MapIterable that is obtained by flipping the direction of this map and making the associations from value to key.MapIterable<Integer, String> map = this.newMapWithKeysValues(1, "1", 2, "2", 3, "3"); MapIterable<String, Integer> result = map.flipUniqueValues(); Assert.assertTrue(result.equals(UnifiedMap.newWithKeysValues("1", 1, "2", 2, "3", 3)));
- Throws:
java.lang.IllegalStateException
- if the MapIterable contains duplicate values.- Since:
- 5.0
-
getIfAbsent
V getIfAbsent(K key, Function0<? extends V> function)
Return the value in the Map that corresponds to the specified key, or if there is no value at the key, return the result of evaluating the specified Function0.
-
getIfAbsentValue
V getIfAbsentValue(K key, V value)
Return the value in the Map that corresponds to the specified key, or if there is no value at the key, returnvalue
.
-
getIfAbsentWith
<P> V getIfAbsentWith(K key, Function<? super P,? extends V> function, P parameter)
Return the value in the Map that corresponds to the specified key, or if there is no value at the key, return the result of evaluating the specified function and parameter.
-
ifPresentApply
<A> A ifPresentApply(K key, Function<? super V,? extends A> function)
If there is a value in the Map that corresponds to the specified key return the result of applying the specified Function on the value, otherwise return null.
-
keysView
RichIterable<K> keysView()
Returns an unmodifiable lazy iterable wrapped around the keySet for the map.
-
valuesView
RichIterable<V> valuesView()
Returns an unmodifiable lazy iterable wrapped around the values for the map.
-
keyValuesView
RichIterable<Pair<K,V>> keyValuesView()
Returns an unmodifiable lazy iterable of key/value pairs wrapped around the entrySet for the map.
-
flip
Multimap<V,K> flip()
Given a map from Domain->
Range return a multimap from Range->
Domain. We chose the name 'flip' rather than 'invert' or 'transpose' since this method does not have the property of applying twice returns the original.Since the keys in the input are unique, the values in the output are unique, so the return type should be a SetMultimap. However, since SetMultimap and SortedSetMultimap don't inherit from one another, SetMultimap here does not allow SortedMapIterable to have a SortedSetMultimap return. Thus, we compromise and call this Multimap, even though all implementations will be a SetMultimap or SortedSetMultimap.
- Since:
- 5.0
-
select
MapIterable<K,V> select(Predicate2<? super K,? super V> predicate)
For each key and value of the map the predicate is evaluated, if the result of the evaluation is true, that key and value are returned in a new map.MapIterable<City, Person> selected = peopleByCity.select((city, person) -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
-
reject
MapIterable<K,V> reject(Predicate2<? super K,? super V> predicate)
For each key and value of the map the predicate is evaluated, if the result of the evaluation is false, that key and value are returned in a new map.MapIterable<City, Person> rejected = peopleByCity.reject((city, person) -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
-
collect
<K2,V2> MapIterable<K2,V2> collect(Function2<? super K,? super V,Pair<K2,V2>> function)
For each key and value of the map the function is evaluated. The results of these evaluations are returned in a new map. The map returned will use the values projected from the function rather than the original values.MapIterable<String, String> collected = peopleByCity.collect((City city, Person person) -> Pair.of(city.getCountry(), person.getAddress().getCity()));
-
collectValues
<R> MapIterable<K,R> collectValues(Function2<? super K,? super V,? extends R> function)
For each key and value of the map the function is evaluated. The results of these evaluations are returned in a new map. The map returned will use the values projected from the function rather than the original values.MapIterable<City, String> collected = peopleByCity.collectValues((City city, Person person) -> person.getFirstName() + " " + person.getLastName());
-
detect
Pair<K,V> detect(Predicate2<? super K,? super V> predicate)
Return the first key and value of the map for which the predicate evaluates to true when they are given as arguments. The predicate will only be evaluated until such pair is found or until all the keys and values of the map have been used as arguments. That is, there may be keys and values of the map that are never used as arguments to the predicate. The result is null if predicate does not evaluate to true for any key/value combination.Pair<City, Person> detected = peopleByCity.detect((City city, Person person) -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
-
detectOptional
java.util.Optional<Pair<K,V>> detectOptional(Predicate2<? super K,? super V> predicate)
Return the first key and value of the map as an Optional for which the predicate evaluates to true when they are given as arguments. The predicate will only be evaluated until such pair is found or until all the keys and values of the map have been used as arguments. That is, there may be keys and values of the map that are never used as arguments to the predicate.Optional<Pair<City, Person>> detected = peopleByCity.detectOptional((city, person) -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
-
equals
boolean equals(java.lang.Object o)
Follows the same general contract asMap.equals(Object)
.- Overrides:
equals
in classjava.lang.Object
-
hashCode
int hashCode()
Follows the same general contract asMap.hashCode()
.- Overrides:
hashCode
in classjava.lang.Object
-
toString
java.lang.String toString()
Returns a string with the keys and values of this map separated by commas with spaces and enclosed in curly braces. Each key and value is separated by an equals sign.Assert.assertEquals("{1=1, 2=2, 3=3}", Maps.mutable.with(1, 1, 2, 2, 3, 3).toString());
- Specified by:
toString
in interfaceRichIterable<K>
- Overrides:
toString
in classjava.lang.Object
- Returns:
- a string representation of this MapIterable
- See Also:
AbstractMap.toString()
-
toImmutable
ImmutableMapIterable<K,V> toImmutable()
-
stream
default java.util.stream.Stream<V> stream()
- Since:
- 9.0
-
parallelStream
default java.util.stream.Stream<V> parallelStream()
- Since:
- 9.0
-
spliterator
default java.util.Spliterator<V> spliterator()
- Specified by:
spliterator
in interfacejava.lang.Iterable<K>
- Since:
- 9.0
-
aggregateBy
default <K1,V1,V2> MapIterable<K1,V2> aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
Applies an aggregate function over the map grouping results into a map based on the specific key and value groupBy functions. Aggregate results are allowed to be immutable as they will be replaced in place in the map. A second function specifies the initial "zero" aggregate value to work with.MapIterable<String, Interval> map = Maps.mutable.with("oneToFive", Interval.fromTo(1, 5), "sixToNine", Interval.fromTo(6, 9)); MapIterable<String, Long> result = map.aggregateBy( eachKey -> { return eachKey.equals("oneToFive") ? "lessThanSix" : "greaterOrEqualsToSix"; }, each -> each.sumOfInt(Integer::intValue), () -> 0L, (argument1, argument2) -> argument1 + argument2); MapIterable<String, Long> expected = Maps.mutable.with("lessThanSix", Interval.fromTo(1, 5).sumOfInt(Integer::intValue), "greaterOrEqualsToSix", Interval.fromTo(6, 9).sumOfInt(Integer::intValue)); Assert.assertEquals(expected, result);
- Since:
- 10.3.0
-
-