Package 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>
All Known Implementing Classes:
AbstractBiMap, AbstractImmutableBiMap, AbstractImmutableMap, AbstractImmutableSortedMap, AbstractMapIterable, AbstractMutableMap, AbstractMutableMapIterable, AbstractMutableSortedMap, AbstractSynchronizedMapIterable, ConcurrentHashMap, ConcurrentHashMapUnsafe, ConcurrentMutableHashMap, HashBiMap, ImmutableTreeMap, ImmutableUnifiedMap, ImmutableUnifiedMapWithHashingStrategy, MapAdapter, OrderedMapAdapter, SortedMapAdapter, SynchronizedBiMap, SynchronizedMutableMap, SynchronizedSortedMap, TreeSortedMap, 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 Details

    • get

      V get(Object key)
      See Also:

    • containsKey

      boolean containsKey(Object key)
      See Also:

    • containsValue

      boolean containsValue(Object value)
      See Also:

    • 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<K>
      Since:
      6.0
      See Also:

    • 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");

    • 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 of 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 of 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<K>
      Overrides:
      toString in class Object
      Returns:
      a string representation of this MapIterable
      See Also:

    • 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<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