AbstractMutableMapIterable (Eclipse Collections

java.lang.Object
- org.eclipse.collections.impl.AbstractRichIterable<V>
- - org.eclipse.collections.impl.map.AbstractMapIterable<K,V>
  - - org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable<K,V>

All Implemented Interfaces:

Iterable<K>, Map<K,V>, InternalIterable<K>, MapIterable<K,V>, MutableMapIterable<K,V>, RichIterable<K>

Direct Known Subclasses:

AbstractMutableMap, AbstractMutableSortedMap
```
public abstract class AbstractMutableMapIterable<K,V>
extends AbstractMapIterable<K,V>
implements MutableMapIterable<K,V>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K extends Object,V extends Object>

Constructor Summary

Constructors
Constructor Description

AbstractMutableMapIterable()

Constructors
Constructor	Description
`AbstractMutableMapIterable()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`<K2,V2> MutableMap<K2,V2>`	`aggregateBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V,? extends V2> nonMutatingAggregator)`	Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function.
`<K2,V2> MutableMap<K2,V2>`	`aggregateInPlaceBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Procedure2<? super V2,? super V> mutatingAggregator)`	Applies an aggregate procedure over the iterable grouping results into a Map based on the specific groupBy function.
`<K2,V2> MutableMap<K2,V2>`	`collect(Function2<? super K,? super V,Pair<K2,V2>> function)`	For each key and value of the map the function is evaluated.
`<V1> MutableBag<V1>`	`countBy(Function<? super V,? extends V1> function)`	This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.
`<V1> MutableBag<V1>`	`countByEach(Function<? super V,? extends Iterable<V1>> function)`	This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.
`<V1,P> MutableBag<V1>`	`countByWith(Function2<? super V,? super P,? extends V1> function, P parameter)`	This method will count the number of occurrences of each value calculated by applying the function to each element of the collection with the specified parameter as the second argument.
`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.
`MutableMap<V,K>`	`flipUniqueValues()`	Return the MapIterable that is obtained by flipping the direction of this map and making the associations from value to key.
`V`	`getIfAbsentPut(K key, Function0<? extends V> function)`	Get and return the value in the Map at the specified key.
`V`	`getIfAbsentPut(K key, V value)`	Get and return the value in the Map at the specified key.
`<P> V`	`getIfAbsentPutWith(K key, Function<? super P,? extends V> function, P parameter)`	Get and return the value in the Map at the specified key.
`V`	`getIfAbsentPutWithKey(K key, Function<? super K,? extends V> function)`	Get and return the value in the Map at the specified key.
`<VV> MutableMapIterable<VV,V>`	`groupByUniqueKey(Function<? super V,? extends VV> function)`	For each element of the iterable, the function is evaluated and he results of these evaluations are collected into a new map, where the transformed value is the key.
`Iterator<V>`	`iterator()`
`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.
`<V1> MutableObjectDoubleMap<V1>`	`sumByDouble(Function<? super V,? extends V1> groupBy, DoubleFunction<? super V> function)`	Groups and sums the values using the two specified functions.
`<V1> MutableObjectDoubleMap<V1>`	`sumByFloat(Function<? super V,? extends V1> groupBy, FloatFunction<? super V> function)`	Groups and sums the values using the two specified functions.
`<V1> MutableObjectLongMap<V1>`	`sumByInt(Function<? super V,? extends V1> groupBy, IntFunction<? super V> function)`	Groups and sums the values using the two specified functions.
`<V1> MutableObjectLongMap<V1>`	`sumByLong(Function<? super V,? extends V1> groupBy, LongFunction<? super V> function)`	Groups and sums the values using the two specified functions.
`V`	`updateValue(K key, Function0<? extends V> factory, Function<? super V,? extends V> function)`	Looks up the value associated with `key`, applies the `function` to it, and replaces the value.
`<P> V`	`updateValueWith(K key, Function0<? extends V> factory, Function2<? super V,? super P,? extends V> function, P parameter)`	Same as `MutableMapIterable.updateValue(Object, Function0, Function)` with a Function2 and specified parameter which is passed to the function.
`RichIterable<V>`	`valuesView()`	Returns an unmodifiable lazy iterable wrapped around the values for the map.

Methods inherited from class org.eclipse.collections.impl.map.AbstractMapIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, asLazy, chunk, contains, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, forEachKey, forEachValue, forEachWith, forEachWithIndex, getFirst, getIfAbsent, getIfAbsentValue, getIfAbsentWith, getLast, getOnly, ifPresentApply, noneSatisfy, noneSatisfyWith, toArray, toArray

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable
appendString, appendString, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, containsAll, containsAllArguments, containsAllIterable, count, countWith, flatCollect, forEach, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, isEmpty, max, max, maxBy, min, min, minBy, reject, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toBiMap, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach, forEachWith, forEachWithIndex

Methods inherited from interface java.util.Map
clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entry, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, of, of, of, of, of, of, of, of, of, of, of, ofEntries, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, size, values

Methods inherited from interface org.eclipse.collections.api.map.MapIterable
containsKey, containsValue, equals, forEachKey, forEachKeyValue, forEachValue, get, getIfAbsent, getIfAbsentValue, getIfAbsentWith, hashCode, ifPresentApply, parallelStream, spliterator, stream, toString

Methods inherited from interface org.eclipse.collections.api.map.MutableMapIterable
add, asSynchronized, asUnmodifiable, collectValues, flip, groupBy, groupByEach, newEmpty, partition, putPair, reject, reject, rejectWith, removeAllKeys, removeIf, removeKey, select, select, selectInstancesOf, selectWith, tap, toImmutable, withAllKeyValueArguments, withAllKeyValues, withKeyValue, withoutAllKeys, withoutKey, zip, zipWithIndex

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.collections.api.RichIterable
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, count, countBy, countByEach, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollect, flatCollectWith, flatCollectWith, forEach, getAny, getFirst, getLast, getOnly, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, isEmpty, makeString, makeString, makeString, max, max, maxBy, maxByOptional, maxOptional, maxOptional, min, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, notEmpty, partitionWith, reduce, reduceInPlace, reduceInPlace, reject, rejectWith, select, selectWith, size, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndex

- Constructor Detail
  - AbstractMutableMapIterable
```
public AbstractMutableMapIterable()
```
- Method Detail
  - iterator
```
public Iterator<V> iterator()
```
    Specified by:
    
    iterator in interface Iterable<K>
  - getIfAbsentPut
```
public V getIfAbsentPut(K key,
                        Function0<? extends V> function)
```
    Description copied from interface: MutableMapIterable
    
    Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map at the key, return the result of evaluating the specified Function0, and put that value in the map at the specified key.
    
    Specified by:
    
    getIfAbsentPut in interface MutableMapIterable<K,V>
  - getIfAbsentPut
```
public V getIfAbsentPut(K key,
                        V value)
```
    Description copied from interface: MutableMapIterable
    
    Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map at the key, return the specified value, and put that value in the map at the specified key.
    
    Specified by:
    
    getIfAbsentPut in interface MutableMapIterable<K,V>
  - getIfAbsentPutWithKey
```
public V getIfAbsentPutWithKey(K key,
                               Function<? super K,? extends V> function)
```
    Description copied from interface: MutableMapIterable
    
    Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map for that key return the result of evaluating the specified Function using the specified key, and put that value in the map at the specified key.
    
    Specified by:
    
    getIfAbsentPutWithKey in interface MutableMapIterable<K,V>
  - getIfAbsentPutWith
```
public <P> V getIfAbsentPutWith(K key,
                                Function<? super P,? extends V> function,
                                P parameter)
```
    Description copied from interface: MutableMapIterable
    
    Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map for that key return the result of evaluating the specified Function using the specified parameter, and put that value in the map at the specified key.
    
    Specified by:
    
    getIfAbsentPutWith in interface MutableMapIterable<K,V>
  - updateValue
```
public V updateValue(K key,
                     Function0<? extends V> factory,
                     Function<? super V,? extends V> function)
```
    Description copied from interface: MutableMapIterable
    
    Looks up the value associated with key, applies the function to it, and replaces the value. If there is no value associated with key, starts it off with a value supplied by factory.
    
    Specified by:
    
    updateValue in interface MutableMapIterable<K,V>
  - updateValueWith
```
public <P> V updateValueWith(K key,
                             Function0<? extends V> factory,
                             Function2<? super V,? super P,? extends V> function,
                             P parameter)
```
    Description copied from interface: MutableMapIterable
    
    Same as MutableMapIterable.updateValue(Object, Function0, Function) with a Function2 and specified parameter which is passed to the function.
    
    Specified by:
    
    updateValueWith in interface MutableMapIterable<K,V>
  - groupByUniqueKey
```
public <VV> MutableMapIterable<VV,V> groupByUniqueKey(Function<? super V,? extends VV> function)
```
    Description copied from interface: RichIterable
    
    For each element of the iterable, the function is evaluated and he results of these evaluations are collected into a new map, where the transformed value is the key. The generated keys must each be unique, or else an exception is thrown.
    
    Specified by:
    
    groupByUniqueKey in interface MutableMapIterable<K,V>
    
    Specified by:
    
    groupByUniqueKey in interface RichIterable<K>
    
    See Also:
    
    RichIterable.groupBy(Function)
  - aggregateInPlaceBy
```
public <K2,V2> MutableMap<K2,V2> aggregateInPlaceBy(Function<? super V,? extends K2> groupBy,
                                                    Function0<? extends V2> zeroValueFactory,
                                                    Procedure2<? super V2,? super V> mutatingAggregator)
```
    Description copied from interface: RichIterable
    
    Applies an aggregate procedure over the iterable grouping results into a Map based on the specific groupBy function. Aggregate results are required to be mutable as they will be changed in place by the procedure. A second function specifies the initial "zero" aggregate value to work with (i.e. new AtomicInteger(0)).
    
    Specified by:
    
    aggregateInPlaceBy in interface MutableMapIterable<K,V>
    
    Specified by:
    
    aggregateInPlaceBy in interface RichIterable<K>
  - aggregateBy
```
public <K2,V2> MutableMap<K2,V2> aggregateBy(Function<? super V,? extends K2> groupBy,
                                             Function0<? extends V2> zeroValueFactory,
                                             Function2<? super V2,? super V,? extends V2> nonMutatingAggregator)
```
    Description copied from interface: RichIterable
    
    Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. 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 (i.e. Integer.valueOf(0)).
    
    Specified by:
    
    aggregateBy in interface MutableMapIterable<K,V>
    
    Specified by:
    
    aggregateBy in interface RichIterable<K>
  - keysView
```
public RichIterable<K> keysView()
```
    Description copied from interface: MapIterable
    
    Returns an unmodifiable lazy iterable wrapped around the keySet for the map.
    
    Specified by:
    
    keysView in interface MapIterable<K,V>
  - valuesView
```
public RichIterable<V> valuesView()
```
    Description copied from interface: MapIterable
    
    Returns an unmodifiable lazy iterable wrapped around the values for the map.
    
    Specified by:
    
    valuesView in interface MapIterable<K,V>
  - keyValuesView
```
public RichIterable<Pair<K,V>> keyValuesView()
```
    Description copied from interface: MapIterable
    
    Returns an unmodifiable lazy iterable of key/value pairs wrapped around the entrySet for the map.
    
    Specified by:
    
    keyValuesView in interface MapIterable<K,V>
  - collect
```
public <K2,V2> MutableMap<K2,V2> collect(Function2<? super K,? super V,Pair<K2,V2>> function)
```
    Description copied from interface: MapIterable
    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()));
 
```
    Specified by:
    
    collect in interface MapIterable<K,V>
    
    Specified by:
    
    collect in interface MutableMapIterable<K,V>
  - flipUniqueValues
```
public MutableMap<V,K> flipUniqueValues()
```
    Description copied from interface: MapIterable
    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)));
 
```
    Specified by:
    
    flipUniqueValues in interface MapIterable<K,V>
    
    Specified by:
    
    flipUniqueValues in interface MutableMapIterable<K,V>
  - detect
```
public Pair<K,V> detect(Predicate2<? super K,? super V> predicate)
```
    Description copied from interface: MapIterable
    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"));
 
```
    Specified by:
    
    detect in interface MapIterable<K,V>
  - detectOptional
```
public Optional<Pair<K,V>> detectOptional(Predicate2<? super K,? super V> predicate)
```
    Description copied from interface: MapIterable
    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"));
 
```
    Specified by:
    
    detectOptional in interface MapIterable<K,V>
  - sumByInt
```
public <V1> MutableObjectLongMap<V1> sumByInt(Function<? super V,? extends V1> groupBy,
                                              IntFunction<? super V> function)
```
    Description copied from interface: RichIterable
    
    Groups and sums the values using the two specified functions.
    
    Specified by:
    
    sumByInt in interface MutableMapIterable<K,V>
    
    Specified by:
    
    sumByInt in interface RichIterable<K>
  - sumByFloat
```
public <V1> MutableObjectDoubleMap<V1> sumByFloat(Function<? super V,? extends V1> groupBy,
                                                  FloatFunction<? super V> function)
```
    Description copied from interface: RichIterable
    
    Groups and sums the values using the two specified functions.
    
    Specified by:
    
    sumByFloat in interface MutableMapIterable<K,V>
    
    Specified by:
    
    sumByFloat in interface RichIterable<K>
  - sumByLong
```
public <V1> MutableObjectLongMap<V1> sumByLong(Function<? super V,? extends V1> groupBy,
                                               LongFunction<? super V> function)
```
    Description copied from interface: RichIterable
    
    Groups and sums the values using the two specified functions.
    
    Specified by:
    
    sumByLong in interface MutableMapIterable<K,V>
    
    Specified by:
    
    sumByLong in interface RichIterable<K>
  - sumByDouble
```
public <V1> MutableObjectDoubleMap<V1> sumByDouble(Function<? super V,? extends V1> groupBy,
                                                   DoubleFunction<? super V> function)
```
    Description copied from interface: RichIterable
    
    Groups and sums the values using the two specified functions.
    
    Specified by:
    
    sumByDouble in interface MutableMapIterable<K,V>
    
    Specified by:
    
    sumByDouble in interface RichIterable<K>
  - countBy
```
public <V1> MutableBag<V1> countBy(Function<? super V,? extends V1> function)
```
    Description copied from interface: RichIterable
    
    This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.
    
    Specified by:
    
    countBy in interface MutableMapIterable<K,V>
    
    Specified by:
    
    countBy in interface RichIterable<K>
    
    Since:
    
    9.0
  - countByWith
```
public <V1,P> MutableBag<V1> countByWith(Function2<? super V,? super P,? extends V1> function,
                                         P parameter)
```
    Description copied from interface: RichIterable
    
    This method will count the number of occurrences of each value calculated by applying the function to each element of the collection with the specified parameter as the second argument.
    
    Specified by:
    
    countByWith in interface MutableMapIterable<K,V>
    
    Specified by:
    
    countByWith in interface RichIterable<K>
    
    Since:
    
    9.0
  - countByEach
```
public <V1> MutableBag<V1> countByEach(Function<? super V,? extends Iterable<V1>> function)
```
    Description copied from interface: RichIterable
    
    This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.
    
    Specified by:
    
    countByEach in interface MutableMapIterable<K,V>
    
    Specified by:
    
    countByEach in interface RichIterable<K>
    
    Overrides:
    
    countByEach in class AbstractRichIterable<V>
    
    Since:
    
    10.0.0

Class AbstractMutableMapIterable<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.collections.impl.map.AbstractMapIterable

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable

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

Methods inherited from interface java.util.Map

Methods inherited from interface org.eclipse.collections.api.map.MapIterable

Methods inherited from interface org.eclipse.collections.api.map.MutableMapIterable

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractMutableMapIterable

Method Detail

iterator

getIfAbsentPut

getIfAbsentPut

getIfAbsentPutWithKey

getIfAbsentPutWith

updateValue

updateValueWith

groupByUniqueKey

aggregateInPlaceBy

aggregateBy

keysView

valuesView

keyValuesView

collect

flipUniqueValues

detect

detectOptional

sumByInt

sumByFloat

sumByLong

sumByDouble

countBy

countByWith

countByEach