MutableMap#asUnmodifiable()
| Modifier and Type | Field and Description |
|---|---|
| private final MutableOrderedMap | |
| private static final long |
| Access | Constructor and Description |
|---|---|
| public |
| Modifier and Type | Method and Description |
|---|---|
| public <KK, VV> MutableOrderedMap | aggregateBy(Function<? super V, ? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV, ? super V, ? extends VV> nonMutatingAggregator)
Implements org. Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. |
| public <K1, V1, V2> MutableOrderedMap | 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)
Implements org. Applies an aggregate function over the map grouping results into a map based on the specific key and value groupBy functions. |
| public <KK, VV> MutableOrderedMap | aggregateInPlaceBy(Function<? super V, ? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV, ? super V> mutatingAggregator)
Implements org. Applies an aggregate procedure over the iterable grouping results into a Map based on the specific groupBy function. |
| public boolean | allSatisfy(Predicate<? super V> predicate)
Implements org. Returns true if the predicate evaluates to true for every element of the iterable or if the iterable is empty. |
| public <P> boolean | allSatisfyWith(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Returns true if the predicate evaluates to true for every element of the collection, or returns false. |
| public boolean | anySatisfy(Predicate<? super V> predicate)
Implements org. Returns true if the predicate evaluates to true for any element of the iterable. |
| public <P> boolean | anySatisfyWith(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Returns true if the predicate evaluates to true for any element of the collection, or return false. |
| public void | appendString(Appendable appendable)
Overrides default org. Prints a string representation of this collection onto the given |
| public void | appendString(Appendable appendable, String separator)
Overrides default org. Prints a string representation of this collection onto the given |
| public void | appendString(Appendable appendable, String start, String separator, String end)
Implements org. Prints a string representation of this collection onto the given |
| public LazyIterable | asLazy()
Implements org. Returns a lazy (deferred) iterable, most likely implemented by calling LazyIterate.adapt(this). |
| public MutableMapIterable | asSynchronized()
Implements org. Returns a synchronized wrapper backed by this map. |
| public MutableOrderedMap | asUnmodifiable()
Implements org. Returns an unmodifiable view of this map. |
| public RichIterable | chunk(int size)
Implements org. Partitions elements in fixed size chunks. |
| public void | clear()
Implements java. Removes all of the mappings from this map (optional operation). |
| public <K2, V2> MutableOrderedMap | collect(Function2<? super K, ? super V, Pair<K2, V2>> function)
Implements org. For each key and value of the map the function is evaluated. |
| public <VV> MutableList | collect(Function<? super V, ? extends VV> function)
Implements org. Returns a new collection with the results of applying the specified function on each element of the source collection. |
| public <VV, R extends Collection | collect(Function<? super V, ? extends VV> function, R target)
Implements org. Same as |
| public MutableBooleanList | collectBoolean(BooleanFunction<? super V> booleanFunction)
Implements org. Returns a new primitive |
| public <R extends MutableBooleanCollection> R | collectBoolean(BooleanFunction<? super V> booleanFunction, R target)
Overrides default org. Same as |
| public MutableByteList | collectByte(ByteFunction<? super V> byteFunction)
Implements org. Returns a new primitive |
| public <R extends MutableByteCollection> R | collectByte(ByteFunction<? super V> byteFunction, R target)
Overrides default org. Same as |
| public MutableCharList | collectChar(CharFunction<? super V> charFunction)
Implements org. Returns a new primitive |
| public <R extends MutableCharCollection> R | collectChar(CharFunction<? super V> charFunction, R target)
Overrides default org. Same as |
| public MutableDoubleList | collectDouble(DoubleFunction<? super V> doubleFunction)
Implements org. Returns a new primitive |
| public <R extends MutableDoubleCollection> R | collectDouble(DoubleFunction<? super V> doubleFunction, R target)
Overrides default org. Same as |
| public MutableFloatList | collectFloat(FloatFunction<? super V> floatFunction)
Implements org. Returns a new primitive |
| public <R extends MutableFloatCollection> R | collectFloat(FloatFunction<? super V> floatFunction, R target)
Overrides default org. Same as |
| public <VV> MutableList | collectIf(Predicate<? super V> predicate, Function<? super V, ? extends VV> function)
Implements org. Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate. |
| public <VV, R extends Collection | collectIf(Predicate<? super V> predicate, Function<? super V, ? extends VV> function, R target)
Implements org. Same as the collectIf method with two parameters but uses the specified target collection for the results. |
| public MutableIntList | collectInt(IntFunction<? super V> intFunction)
Implements org. Returns a new primitive |
| public <R extends MutableIntCollection> R | collectInt(IntFunction<? super V> intFunction, R target)
Overrides default org. Same as |
| public <R> MutableOrderedMap | collectKeysUnique(Function2<? super K, ? super V, ? extends R> function)
Implements org. For each key and value of the map the function is evaluated. |
| public MutableLongList | collectLong(LongFunction<? super V> longFunction)
Implements org. Returns a new primitive |
| public <R extends MutableLongCollection> R | collectLong(LongFunction<? super V> longFunction, R target)
Overrides default org. Same as |
| public MutableShortList | collectShort(ShortFunction<? super V> shortFunction)
Implements org. Returns a new primitive |
| public <R extends MutableShortCollection> R | collectShort(ShortFunction<? super V> shortFunction, R target)
Overrides default org. Same as |
| public <R> MutableOrderedMap | collectValues(Function2<? super K, ? super V, ? extends R> function)
Implements org. For each key and value of the map the function is evaluated. |
| public <P, VV> MutableList | collectWith(Function2<? super V, ? super P, ? extends VV> function, P parameter)
Implements org. Same as |
| public <P, VV, R extends Collection | collectWith(Function2<? super V, ? super P, ? extends VV> function, P parameter, R targetCollection)
Implements org. Same as collectWith but with a targetCollection parameter to gather the results. |
| public <V1> ReversibleIterable | collectWithIndex(ObjectIntToObjectFunction<? super V, ? extends V1> function)
Overrides default org. Returns a new OrderedIterable using results obtained by applying the specified function to each element and its corresponding index. |
| public <VV, R extends Collection | collectWithIndex(ObjectIntToObjectFunction<? super V, ? extends VV> function, R target)
Overrides default org. Adds elements to the target Collection using results obtained by applying the specified function to each element and its corresponding index. |
| public boolean | contains(Object object)
Implements org. Returns true if the iterable has an element which responds true to element.equals(object). |
| public boolean | containsAll(Collection<?> source)
Implements org. Returns true if all elements in source are contained in this collection. |
| public boolean | containsAllArguments(Object... elements)
Implements org. Returns true if all elements in the specified var arg array are contained in this collection. |
| public boolean | containsAllIterable(Iterable<?> source)
Implements org. Returns true if all elements in source are contained in this collection. |
| public boolean | containsKey(Object key)
Implements org. Returns |
| public boolean | containsValue(Object value)
Implements org. Returns |
| public <S> boolean | corresponds(OrderedIterable<S> other, Predicate2<? super V, ? super S> predicate)
Implements org. Returns true if both OrderedIterables have the same length
and |
| public int | count(Predicate<? super V> predicate)
Implements org. Return the total number of elements that answer true to the specified predicate. |
| public <VV> MutableBag | countBy(Function<? super V, ? extends VV> function)
Overrides default org. This method will count the number of occurrences of each value calculated by applying the function to each element of the collection. |
| public <VV, R extends MutableBagIterable | countBy(Function<? super V, ? extends VV> function, R target)
Overrides default org. This method will count the number of occurrences of each value calculated by applying the function to each element of the collection. |
| public <VV, P> MutableBag | countByWith(Function2<? super V, ? super P, ? extends VV> function, P parameter)
Overrides default org. 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. |
| public <VV, P, R extends MutableBagIterable | countByWith(Function2<? super V, ? super P, ? extends VV> function, P parameter, R target)
Overrides default org. 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. |
| public <P> int | countWith(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Returns the total number of elements that evaluate to true for the specified predicate. |
| public Pair | detect(Predicate2<? super K, ? super V> predicate)
Implements org. Return the first key and value of the map for which the predicate evaluates to true when they are given as arguments. |
| public V | detect(Predicate<? super V> predicate)
Implements org. Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no element returns true. |
| public V | detectIfNone(Predicate<? super V> predicate, Function0<? extends V> function)
Overrides default org. Returns the first element of the iterable for which the predicate evaluates to true. |
| public int | detectIndex(Predicate<? super V> predicate)
Implements org. Returns the index of the first element of the |
| public int | detectLastIndex(Predicate<? super V> predicate)
Implements org. Returns the index of the last element of the |
| public Optional | detectOptional(Predicate2<? super K, ? super V> predicate)
Implements org. 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. |
| public Optional | detectOptional(Predicate<? super V> predicate)
Implements org. Returns the first element of the iterable for which the predicate evaluates to true as an Optional. |
| public <P> V | detectWith(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Returns the first element that evaluates to true for the specified predicate2 and parameter, or null if none evaluate to true. |
| public <P> V | detectWithIfNone(Predicate2<? super V, ? super P> predicate, P parameter, Function0<? extends V> function)
Implements org. Returns the first element of the iterable that evaluates to true for the specified predicate2 and parameter, or returns the value of evaluating the specified function. |
| public <P> Optional | detectWithOptional(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Returns the first element that evaluates to true for the specified predicate2 and parameter as an Optional. |
| public MutableList | distinct()
Implements org. Returns a new |
| public MutableOrderedMap | drop(int count)
Implements org. Returns an iterable after skipping the first |
| public MutableOrderedMap | dropWhile(Predicate<? super V> predicate)
Implements org. Returns the final elements that do not satisfy the Predicate. |
| public void | each(Procedure<? super V> procedure)
Implements org. The procedure is executed for each element in the iterable. |
| public Set | entrySet()
Implements java. Returns a |
| public boolean | equals(Object o)
Overrides java. Implements org. Follows the same general contract as |
| public <VV> MutableList | flatCollect(Function<? super V, ? extends Iterable<VV>> function)
Implements org.
|
| public <VV, R extends Collection | flatCollect(Function<? super V, ? extends Iterable<VV>> function, R target)
Implements org. Same as flatCollect, only the results are collected into the target collection. |
| public <R extends MutableBooleanCollection> R | flatCollectBoolean(Function<? super V, ? extends BooleanIterable> function, R target)
Overrides default org. Same as flatCollect, only the results are collected into the target collection. |
| public <R extends MutableByteCollection> R | flatCollectByte(Function<? super V, ? extends ByteIterable> function, R target)
Overrides default org. Same as flatCollect, only the results are collected into the target collection. |
| public <R extends MutableCharCollection> R | flatCollectChar(Function<? super V, ? extends CharIterable> function, R target)
Overrides default org. Same as flatCollect, only the results are collected into the target collection. |
| public <R extends MutableDoubleCollection> R | flatCollectDouble(Function<? super V, ? extends DoubleIterable> function, R target)
Overrides default org. Same as flatCollect, only the results are collected into the target collection. |
| public <R extends MutableFloatCollection> R | flatCollectFloat(Function<? super V, ? extends FloatIterable> function, R target)
Overrides default org. Same as flatCollect, only the results are collected into the target collection. |
| public <R extends MutableIntCollection> R | flatCollectInt(Function<? super V, ? extends IntIterable> function, R target)
Overrides default org. Same as flatCollect, only the results are collected into the target collection. |
| public <R extends MutableLongCollection> R | flatCollectLong(Function<? super V, ? extends LongIterable> function, R target)
Overrides default org. Same as flatCollect, only the results are collected into the target collection. |
| public <R extends MutableShortCollection> R | flatCollectShort(Function<? super V, ? extends ShortIterable> function, R target)
Overrides default org. Same as flatCollect, only the results are collected into the target collection. |
| public <P, VV> MutableList | flatCollectWith(Function2<? super V, ? super P, ? extends Iterable<VV>> function, P parameter)
Overrides default org. Same as flatCollect, only with a Function2 that is passed an extra parameter. |
| public <P, VV, R extends Collection | flatCollectWith(Function2<? super V, ? super P, ? extends Iterable<VV>> function, P parameter, R target)
Overrides default org. Same as flatCollectWith, only the results are collected into the target collection. |
| public MutableListMultimap | flip()
Implements org. Given a map from Domain |
| public MutableOrderedMap | flipUniqueValues()
Implements org. Return the MapIterable that is obtained by flipping the direction of this map and making the associations from value to key. |
| public void | forEach(Consumer<? super V> consumer)
Overrides default org. Performs the given action for each element of the |
| public void | forEach(int startIndex, int endIndex, Procedure<? super V> procedure)
Implements org. Iterates over the section of the iterable covered by the specified inclusive indexes. |
| public void | forEachKey(Procedure<? super K> procedure)
Implements org. Calls the |
| public void | forEachKeyValue(Procedure2<? super K, ? super V> procedure)
Implements org. Calls the |
| public void | forEachValue(Procedure<? super V> procedure)
Implements org. Calls the procedure with each value of the map. |
| public <P> void | forEachWith(Procedure2<? super V, ? super P> procedure, P parameter)
Implements org. The procedure2 is evaluated for each element in the iterable with the specified parameter provided as the second argument. |
| public void | forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)
Implements org. Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure. |
| public void | forEachWithIndex(int fromIndex, int toIndex, ObjectIntProcedure<? super V> objectIntProcedure)
Implements org. Iterates over the section of the iterable covered by the specified inclusive indexes. |
| public V | get(Object key)
Implements org. Returns the value to which the specified key is mapped,
or |
| public V | getFirst()
Implements org. Returns the first element of an iterable. |
| public Optional | getFirstOptional()
Overrides default org. Returns the first element of an iterable as an Optional. |
| public V | getIfAbsent(K key, Function0<? extends V> function)
Implements org. 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. |
| public V | getIfAbsentPut(K key, Function0<? extends V> function)
Implements org. Get and return the value in the Map at the specified key. |
| public V | getIfAbsentPut(K key, V value)
Implements org. Get and return the value in the Map at the specified key. |
| public <P> V | getIfAbsentPutWith(K key, Function<? super P, ? extends V> function, P parameter)
Implements org. Get and return the value in the Map at the specified key. |
| public V | getIfAbsentPutWithKey(K key, Function<? super K, ? extends V> function)
Implements org. Get and return the value in the Map at the specified key. |
| public V | getIfAbsentValue(K key, V value)
Implements org. Return the value in the Map that corresponds to the specified key, or if there is no value at the key, return |
| public <P> V | getIfAbsentWith(K key, Function<? super P, ? extends V> function, P parameter)
Implements org. 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. |
| public V | getLast()
Implements org. Returns the last element of an iterable. |
| public Optional | getLastOptional()
Overrides default org. Returns the last element of an iterable as an Optional. |
| public V | getOnly()
Overrides default org. Returns the element if the iterable has exactly one element. |
| public <VV> MutableListMultimap | groupBy(Function<? super V, ? extends VV> function)
Implements org. For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable. |
| public <VV, R extends MutableMultimap | groupBy(Function<? super V, ? extends VV> function, R target)
Implements org. Same as |
| public <VV> MutableListMultimap | groupByEach(Function<? super V, ? extends Iterable<VV>> function)
Implements org. Similar to |
| public <VV, R extends MutableMultimap | groupByEach(Function<? super V, ? extends Iterable<VV>> function, R target)
Implements org. Same as |
| public <VV> MutableOrderedMap | groupByUniqueKey(Function<? super V, ? extends VV> function)
Implements org. For each element of the iterable, the function is evaluated, and the results of these evaluations are collected into a new map, where the transformed value is the key. |
| public <VV, R extends MutableMapIterable | groupByUniqueKey(Function<? super V, ? extends VV> function, R target)
Implements org. Same as |
| public int | hashCode()
Overrides java. Implements org. Follows the same general contract as |
| public <A> A | ifPresentApply(K key, Function<? super V, ? extends A> function)
Implements org. 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. |
| public int | indexOf(Object object)
Overrides default org. Returns the index of the first occurrence of the specified item in this iterable, or -1 if this iterable does not contain the item. |
| public <IV> IV | injectInto(IV injectedValue, Function2<? super IV, ? super V, ? extends IV> function)
Implements org. Returns the final result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. |
| public int | injectInto(int injectedValue, IntObjectToIntFunction<? super V> function)
Implements org. Returns the final int result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. |
| public long | injectInto(long injectedValue, LongObjectToLongFunction<? super V> function)
Implements org. Returns the final long result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. |
| public float | injectInto(float injectedValue, FloatObjectToFloatFunction<? super V> function)
Implements org. Returns the final float result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. |
| public double | injectInto(double injectedValue, DoubleObjectToDoubleFunction<? super V> function)
Implements org. Returns the final double result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. |
| public <R extends Collection | into(R target)
Implements org. Adds all the elements in this iterable to the specific target Collection. |
| private boolean | |
| public boolean | isEmpty()
Implements org. Returns true if this iterable has zero items. |
| public Iterator | |
| public Set | |
| public RichIterable | keysView()
Implements org. Returns an unmodifiable lazy iterable wrapped around the keySet for the map. |
| public RichIterable | keyValuesView()
Implements org. Returns an unmodifiable lazy iterable of key/value pairs wrapped around the entrySet for the map. |
| public String | makeString()
Overrides default org. Returns a string representation of this collection by delegating to |
| public String | makeString(String separator)
Overrides default org. Returns a string representation of this collection by delegating to |
| public String | makeString(String start, String separator, String end)
Overrides default org. Returns a string representation of this collection with the elements separated by the specified separator and enclosed between the start and end strings. |
| public V | max(Comparator<? super V> comparator)
Implements org. Returns the maximum element out of this container based on the comparator. |
| public V | max()
Implements org. Returns the maximum element out of this container based on the natural order. |
| public <VV extends Comparable | maxBy(Function<? super V, ? extends VV> function)
Implements org. Returns the maximum elements out of this container based on the natural order of the attribute returned by Function. |
| public <VV extends Comparable | maxByOptional(Function<? super V, ? extends VV> function)
Overrides default org. Returns the maximum elements out of this container based on the natural order of the attribute returned by Function as an Optional. |
| public Optional | maxOptional(Comparator<? super V> comparator)
Overrides default org. Returns the maximum element out of this container based on the comparator as an Optional. |
| public Optional | maxOptional()
Overrides default org. Returns the maximum element out of this container based on the natural order as an Optional. |
| public V | merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)
Overrides default java. If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value (optional operation). |
| public V | min(Comparator<? super V> comparator)
Implements org. Returns the minimum element out of this container based on the comparator. |
| public V | min()
Implements org. Returns the minimum element out of this container based on the natural order. |
| public <VV extends Comparable | minBy(Function<? super V, ? extends VV> function)
Implements org. Returns the minimum elements out of this container based on the natural order of the attribute returned by Function. |
| public <VV extends Comparable | minByOptional(Function<? super V, ? extends VV> function)
Overrides default org. Returns the minimum elements out of this container based on the natural order of the attribute returned by Function as an Optional. |
| public Optional | minOptional(Comparator<? super V> comparator)
Overrides default org. Returns the minimum element out of this container based on the comparator as an Optional. |
| public Optional | minOptional()
Overrides default org. Returns the minimum element out of this container based on the natural order as an Optional. |
| public MutableOrderedMap | newEmpty()
Implements org. Creates a new instance of the same type, using the default capacity and growth parameters. |
| public boolean | noneSatisfy(Predicate<? super V> predicate)
Implements org. Returns true if the predicate evaluates to false for every element of the iterable or if the iterable is empty. |
| public <P> boolean | noneSatisfyWith(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Returns true if the predicate evaluates to false for every element of the collection, or return false. |
| public boolean | notEmpty()
Overrides default org. The English equivalent of !this.isEmpty() |
| public static <K, V> UnmodifiableMutableOrderedMap | |
| public PartitionMutableList | partition(Predicate<? super V> predicate)
Implements org. Filters a collection into a PartitionedIterable based on the evaluation of the predicate. |
| public PartitionMutableList | partitionWhile(Predicate<? super V> predicate)
Implements org. Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements. |
| public <P> PartitionMutableList | partitionWith(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Filters a collection into a PartitionIterable based on the evaluation of the predicate. |
| public V | put(K key, V value)
Implements java. Associates the specified value with the specified key in this map (optional operation). |
| public void | putAll(Map<? extends K, ? extends V> t)
Implements java. Copies all of the mappings from the specified map to this map (optional operation). |
| public void | putAllMapIterable(MapIterable<? extends K, ? extends V> mapIterable)
Overrides default org.
|
| public Optional | reduce(BinaryOperator<V> accumulator)
Overrides default org. This method produces the equivalent result as |
| public <KK> MutableOrderedMap | reduceBy(Function<? super V, ? extends KK> groupBy, Function2<? super V, ? super V, ? extends V> reduceFunction)
Implements org. Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. |
| public <R, A> R | reduceInPlace(Collector<? super V, A, R> collector)
Overrides default org. This method produces the equivalent result as |
| public <R> R | reduceInPlace(Supplier<R> supplier, BiConsumer<R, ? super V> accumulator)
Overrides default org. This method produces the equivalent result as |
| public MutableOrderedMap | reject(Predicate2<? super K, ? super V> predicate)
Implements org. 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. |
| public MutableList | reject(Predicate<? super V> predicate)
Implements org. Returns all elements of the source collection that return false when evaluating of the predicate. |
| public <R extends Collection | reject(Predicate<? super V> predicate, R target)
Implements org. Same as the reject method with one parameter but uses the specified target collection for the results. |
| public <P> MutableList | rejectWith(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Similar to |
| public <P, R extends Collection | rejectWith(Predicate2<? super V, ? super P> predicate, P parameter, R targetCollection)
Implements org. Similar to |
| public V | remove(Object key)
Implements java. Removes the mapping for a key from this map if it is present (optional operation). |
| public boolean | removeAllKeys(Set<? extends K> keys)
Overrides default org. Remove entries from the map at the specified |
| public boolean | removeIf(Predicate2<? super K, ? super V> predicate)
Overrides default org. Remove an entry from the map if the |
| public V | removeKey(K key)
Implements org. Remove an entry from the map at the specified |
| public void | reverseForEach(Procedure<? super V> procedure)
Overrides default org. Evaluates the procedure for each element of the list iterating in reverse order. |
| public void | reverseForEachWithIndex(ObjectIntProcedure<? super V> procedure)
Overrides default org. Evaluates the procedure for each element and it's index in reverse order. |
| public MutableOrderedMap | select(Predicate2<? super K, ? super V> predicate)
Implements org. 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. |
| public MutableList | select(Predicate<? super V> predicate)
Implements org. Returns all elements of the source collection that return true when evaluating the predicate. |
| public <R extends Collection | select(Predicate<? super V> predicate, R target)
Implements org. Same as the select method with one parameter but uses the specified target collection for the results. |
| public <S> MutableList | selectInstancesOf(Class<S> clazz)
Implements org. Returns all elements of the source collection that are instances of the Class |
| public <P> MutableList | selectWith(Predicate2<? super V, ? super P> predicate, P parameter)
Implements org. Similar to |
| public <P, R extends Collection | selectWith(Predicate2<? super V, ? super P> predicate, P parameter, R targetCollection)
Implements org. Similar to |
| public int | size()
Implements org. Returns the number of items in this iterable. |
| public <VV> MutableObjectDoubleMap | sumByDouble(Function<? super V, ? extends VV> groupBy, DoubleFunction<? super V> function)
Implements org. Groups and sums the values using the two specified functions. |
| public <VV> MutableObjectDoubleMap | sumByFloat(Function<? super V, ? extends VV> groupBy, FloatFunction<? super V> function)
Implements org. Groups and sums the values using the two specified functions. |
| public <VV> MutableObjectLongMap | sumByInt(Function<? super V, ? extends VV> groupBy, IntFunction<? super V> function)
Implements org. Groups and sums the values using the two specified functions. |
| public <VV> MutableObjectLongMap | sumByLong(Function<? super V, ? extends VV> groupBy, LongFunction<? super V> function)
Implements org. Groups and sums the values using the two specified functions. |
| public DoubleSummaryStatistics | summarizeDouble(DoubleFunction<? super V> function)
Overrides default org. Returns the result of summarizing the value returned from applying the DoubleFunction to each element of the iterable. |
| public DoubleSummaryStatistics | summarizeFloat(FloatFunction<? super V> function)
Overrides default org. Returns the result of summarizing the value returned from applying the FloatFunction to each element of the iterable. |
| public IntSummaryStatistics | summarizeInt(IntFunction<? super V> function)
Overrides default org. Returns the result of summarizing the value returned from applying the IntFunction to each element of the iterable. |
| public LongSummaryStatistics | summarizeLong(LongFunction<? super V> function)
Overrides default org. Returns the result of summarizing the value returned from applying the LongFunction to each element of the iterable. |
| public double | sumOfDouble(DoubleFunction<? super V> function)
Implements org. Returns the final double result of evaluating function for each element of the iterable and adding the results together. |
| public double | sumOfFloat(FloatFunction<? super V> function)
Implements org. Returns the final double result of evaluating function for each element of the iterable and adding the results together. |
| public long | sumOfInt(IntFunction<? super V> function)
Implements org. Returns the final long result of evaluating function for each element of the iterable and adding the results together. |
| public long | sumOfLong(LongFunction<? super V> function)
Implements org. Returns the final long result of evaluating function for each element of the iterable and adding the results together. |
| public MutableOrderedMap | take(int count)
Implements org. Returns the first |
| public MutableOrderedMap | takeWhile(Predicate<? super V> predicate)
Implements org. Returns the initial elements that satisfy the Predicate. |
| public MutableOrderedMap | tap(Procedure<? super V> procedure)
Implements org. Executes the Procedure for each value of the map and returns |
| public Object[] | toArray()
Overrides default org. Converts this iterable to an array. |
| public <T> T[] | toArray(T[] target)
Overrides default org. Converts this iterable to an array using the specified target array, assuming the target array is as long or longer than the iterable. |
| public MutableBag | toBag()
Implements org. Converts the collection to the default MutableBag implementation. |
| public <NK, NV> MutableBiMap | toBiMap(Function<? super V, ? extends NK> keyFunction, Function<? super V, ? extends NV> valueFunction)
Implements org. Converts the collection to a BiMap implementation using the specified key and value functions. |
| public ImmutableOrderedMap | toImmutable()
Implements org. Returns an immutable copy of this map. |
| public MutableList | toList()
Implements org. Converts the collection to a MutableList implementation. |
| public <NK, NV> MutableMap | toMap(Function<? super V, ? extends NK> keyFunction, Function<? super V, ? extends NV> valueFunction)
Implements org. Converts the collection to a MutableMap implementation using the specified key and value functions. |
| public <NK, NV, R extends Map | toMap(Function<? super V, ? extends NK> keyFunction, Function<? super V, ? extends NV> valueFunction, R target)
Overrides default org. Same as |
| public MutableOrderedMap | toReversed()
Implements org. Returns a new ReversibleIterable in reverse order. |
| public MutableSet | toSet()
Implements org. Converts the collection to a MutableSet implementation. |
| public MutableSortedBag | toSortedBag()
Implements org. Converts the collection to a MutableSortedBag implementation and sorts it using the natural order of the elements. |
| public MutableSortedBag | toSortedBag(Comparator<? super V> comparator)
Implements org. Converts the collection to the MutableSortedBag implementation and sorts it using the specified comparator. |
| public MutableList | toSortedList()
Overrides default org. Converts the collection to a MutableList implementation and sorts it using the natural order of the elements. |
| public MutableList | toSortedList(Comparator<? super V> comparator)
Overrides default org. Converts the collection to a MutableList implementation and sorts it using the specified comparator. |
| public <NK, NV> MutableSortedMap | toSortedMap(Function<? super V, ? extends NK> keyFunction, Function<? super V, ? extends NV> valueFunction)
Implements org. Converts the collection to a MutableSortedMap implementation using the specified key and value functions sorted by the key elements' natural ordering. |
| public <NK, NV> MutableSortedMap | toSortedMap(Comparator<? super NK> comparator, Function<? super V, ? extends NK> keyFunction, Function<? super V, ? extends NV> valueFunction)
Implements org. Converts the collection to a MutableSortedMap implementation using the specified key and value functions sorted by the given comparator. |
| public MutableSortedSet | toSortedSet()
Implements org. Converts the collection to a MutableSortedSet implementation and sorts it using the natural order of the elements. |
| public MutableSortedSet | toSortedSet(Comparator<? super V> comparator)
Implements org. Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator. |
| public String | toString()
Overrides java. Implements org. Returns a string with the keys and values of this map separated by commas with spaces and enclosed in curly braces. |
| public V | updateValue(K key, Function0<? extends V> factory, Function<? super V, ? extends V> function)
Implements org. Looks up the value associated with |
| public <P> V | updateValueWith(K key, Function0<? extends V> factory, Function2<? super V, ? super P, ? extends V> function, P parameter)
Implements org. Same as |
| public Collection | values()
Implements java. Returns a |
| public RichIterable | valuesView()
Implements org. Returns an unmodifiable lazy iterable wrapped around the values for the map. |
| public MutableOrderedMap | withAllKeyValueArguments(Pair<? extends K, ? extends V>... keyValuePairs)
Implements org. Convenience var-args version of withAllKeyValues |
| public MutableOrderedMap | withAllKeyValues(Iterable<? extends Pair<? extends K, ? extends V>> keyValues)
Implements org. This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing elements. |
| public MutableOrderedMap | withKeyValue(K key, V value)
Implements org. This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing elements. |
| public MutableOrderedMap | withMap(Map<? extends K, ? extends V> map)
Overrides default org. Similar to |
| public MutableOrderedMap | withMapIterable(MapIterable<? extends K, ? extends V> mapIterable)
Overrides default org.
|
| public MutableOrderedMap | withoutAllKeys(Iterable<? extends K> keys)
Implements org. This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing elements. |
| public MutableOrderedMap | withoutKey(K key)
Implements org. This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing elements. |
| public <S> MutableList | zip(Iterable<S> that)
Implements org. Returns a |
| public <S, R extends Collection | zip(Iterable<S> that, R target)
Implements org. Same as |
| public MutableList | zipWithIndex()
Implements org. Zips this |
| public <R extends Collection | zipWithIndex(R target)
Implements org. Same as |