Interface MapIterable<K,​V>

    • 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);
         
      • 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:
        java.lang.IllegalStateException - if the MapIterable contains duplicate values.
        Since:
        5.0
      • getOrDefault

        default V getOrDefault​(java.lang.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

        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 as Map.equals(Object).
        Overrides:
        equals in class java.lang.Object
      • hashCode

        int hashCode()
        Follows the same general contract as Map.hashCode().
        Overrides:
        hashCode in class java.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 interface RichIterable<K>
        Overrides:
        toString in class java.lang.Object
        Returns:
        a string representation of this MapIterable
        See Also:
        AbstractMap.toString()
      • 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 interface java.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