org.eclipse.collections.api.map

Interface MapIterable<K,V>

All Superinterfaces:

InternalIterable<V>, 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>

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

Modifier and Type	Method and 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(Object key)
boolean	containsValue(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.
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(Object o) Follows the same general contract as Map.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 the procedure with each key of the map.
void	forEachKeyValue(Procedure2<? super K,? super V> procedure) Calls the procedure 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(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, return value.
<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(Object key, V defaultValue)
int	hashCode() Follows the same general contract as Map.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 the injectInto 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 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 Spliterator<V>	spliterator()
default Stream<V>	stream()
MapIterable<K,V>	tap(Procedure<? super V> procedure) Executes the Procedure for each value of the map and returns this.
ImmutableMapIterable<K,V>	toImmutable()
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.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

Methods inherited from interface org.eclipse.collections.api.InternalIterable

forEach, forEachWith, forEachWithIndex

Methods inherited from interface java.lang.Iterable

iterator

Method Detail

get

V get(Object key)

See Also:

Map.get(Object)

containsKey

boolean containsKey(Object key)

See Also:

Map.containsKey(Object)

containsValue

boolean containsValue(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 returns this.

 return peopleByCity.tap(person -> LOGGER.info(person.getName()));
 

Specified by:

tap in interface RichIterable<V>

Since:

6.0

See Also:

RichIterable.forEach(Procedure)

forEachKey

void forEachKey(Procedure<? super K> procedure)

Calls the procedure 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 the procedure 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 the injectInto 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:

IllegalStateException - if the MapIterable contains duplicate values.

Since:

5.0

getOrDefault

default V getOrDefault(Object key,
                       V defaultValue)

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, return value.

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

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(Object o)

Follows the same general contract as Map.equals(Object).

Overrides:

equals in class Object

hashCode

int hashCode()

Follows the same general contract as Map.hashCode().

Overrides:

hashCode in class Object

toString

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 interface RichIterable<V>

Overrides:

toString in class Object

Returns:

a string representation of this MapIterable

See Also:

AbstractMap.toString()

toImmutable

ImmutableMapIterable<K,V> toImmutable()

stream

default Stream<V> stream()

Since:

9.0

parallelStream

default Stream<V> parallelStream()

Since:

9.0

spliterator

default Spliterator<V> spliterator()

Specified by:

spliterator in interface Iterable<V>

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