Package io.vavr.collection

Interface SortedMap<K,V>

Type Parameters:

K - Key type

V - Value type

All Superinterfaces:

Foldable<Tuple2<K,V>>, Function<K,V>, Function1<K,V>, Iterable<Tuple2<K,V>>, Map<K,V>, Ordered<K>, PartialFunction<K,V>, Serializable, Traversable<Tuple2<K,V>>, Value<Tuple2<K,V>>

All Known Implementing Classes:

TreeMap

public interface SortedMap<K,V>
extends Map<K,V>, Ordered<K>

An immutable SortedMap interface.

Author:

Daniel Dietrich

Field Summary

Fields

Modifier and Type	Field	Description
static final long	serialVersionUID	The serial version UID for serialization.

Method Summary

Modifier and Type	Method	Description
<K2, V2> SortedMap<K2,V2>	bimap(@NonNull Comparator<? super K2> keyComparator, @NonNull Function<? super K,? extends K2> keyMapper, Function<? super V,? extends V2> valueMapper)	Same as bimap(Function, Function), using a specific comparator for keys of the codomain of the given keyMapper.
<K2, V2> SortedMap<K2,V2>	bimap(@NonNull Function<? super K,? extends K2> keyMapper, @NonNull Function<? super V,? extends V2> valueMapper)	Maps this Map to a new Map with different component type by applying a function to its elements.
Tuple2<V,? extends SortedMap<K,V>>	computeIfAbsent(K key, @NonNull Function<? super K,? extends V> mappingFunction)	If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map.
Tuple2<Option<V>,? extends SortedMap<K,V>>	computeIfPresent(K key, @NonNull BiFunction<? super K,? super V,? extends V> remappingFunction)	If the value for the specified key is present, attempts to compute a new mapping given the key and its current mapped value.
SortedMap<K,V>	distinct()	Returns a new Traversable containing the elements of this instance with all duplicates removed.
SortedMap<K,V>	distinctBy(@NonNull Comparator<? super Tuple2<K,V>> comparator)	Returns a new Traversable containing the elements of this instance without duplicates, as determined by the given comparator.
<U> SortedMap<K,V>	distinctBy(@NonNull Function<? super Tuple2<K,V>,? extends U> keyExtractor)	Returns a new Traversable containing the elements of this instance without duplicates, based on keys extracted from elements using keyExtractor.
SortedMap<K,V>	drop(int n)	Returns a new Traversable without the first n elements, or an empty instance if this contains fewer than n elements.
SortedMap<K,V>	dropRight(int n)	Returns a new Traversable without the last n elements, or an empty instance if this contains fewer than n elements.
SortedMap<K,V>	dropUntil(@NonNull Predicate<? super Tuple2<K,V>> predicate)	Returns a new Traversable starting from the first element that satisfies the given predicate, dropping all preceding elements.
SortedMap<K,V>	dropWhile(@NonNull Predicate<? super Tuple2<K,V>> predicate)	Returns a new Traversable starting from the first element that does not satisfy the given predicate, dropping all preceding elements.
SortedMap<K,V>	filter(@NonNull BiPredicate<? super K,? super V> predicate)	Returns a new Map consisting of all elements which satisfy the given predicate.
SortedMap<K,V>	filter(@NonNull Predicate<? super Tuple2<K,V>> predicate)	Returns a new traversable containing only the elements that satisfy the given predicate.
SortedMap<K,V>	filterKeys(@NonNull Predicate<? super K> predicate)	Returns a new Map consisting of all elements with keys which satisfy the given predicate.
SortedMap<K,V>	filterValues(@NonNull Predicate<? super V> predicate)	Returns a new Map consisting of all elements with values which satisfy the given predicate.
<K2, V2> SortedMap<K2,V2>	flatMap(@NonNull Comparator<? super K2> keyComparator, @NonNull BiFunction<? super K,? super V,? extends Iterable<Tuple2<K2,V2>>> mapper)	Same as flatMap(BiFunction) but using a specific comparator for values of the codomain of the given mapper.
<K2, V2> SortedMap<K2,V2>	flatMap(@NonNull BiFunction<? super K,? super V,? extends Iterable<Tuple2<K2,V2>>> mapper)	FlatMaps this Map to a new Map with different component type.
<C> Map<C,? extends SortedMap<K,V>>	groupBy(@NonNull Function<? super Tuple2<K,V>,? extends C> classifier)	Groups elements of this Traversable based on a classifier function.
Iterator<? extends SortedMap<K,V>>	grouped(int size)	Splits this Traversable into consecutive blocks of the given size.
SortedMap<K,V>	init()	Returns all elements of this Traversable except the last one.
Option<? extends SortedMap<K,V>>	initOption()	Returns all elements of this Traversable except the last one, wrapped in an Option.
default boolean	isOrdered()	Indicates whether this Traversable is ordered according to its natural or specified order.
SortedSet<K>	keySet()	Returns the keys contained in this map.
default Tuple2<K,V>	last()	Returns the last element of this Traversable.
<K2, V2> SortedMap<K2,V2>	map(@NonNull Comparator<? super K2> keyComparator, @NonNull BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)	Same as map(BiFunction), using a specific comparator for keys of the codomain of the given mapper.
<K2, V2> SortedMap<K2,V2>	map(@NonNull BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)	Maps the entries of this Map to form a new Map.
<K2> SortedMap<K2,V>	mapKeys(@NonNull Function<? super K,? extends K2> keyMapper)	Maps the keys of this Map while preserving the corresponding values.
<K2> SortedMap<K2,V>	mapKeys(@NonNull Function<? super K,? extends K2> keyMapper, @NonNull BiFunction<? super V,? super V,? extends V> valueMerge)	Maps the keys of this Map while preserving the corresponding values and applying a value merge function on collisions.
<V2> SortedMap<K,V2>	mapValues(@NonNull Function<? super V,? extends V2> valueMapper)	Maps the values of this Map while preserving the corresponding keys.
SortedMap<K,V>	merge(@NonNull Map<? extends K,? extends V> that)	Creates a new map which by merging the entries of this map and that map.
<U extends V> SortedMap<K,V>	merge(@NonNull Map<? extends K,U> that, @NonNull BiFunction<? super V,? super U,? extends V> collisionResolution)	Creates a new map which by merging the entries of this map and that map.
static <K, V> SortedMap<K,V>	narrow(SortedMap<? extends K,? extends V> sortedMap)	Narrows a widened SortedMap<? extends K, ? extends V> to SortedMap<K, V> by performing a type-safe cast.
SortedMap<K,V>	orElse(Iterable<? extends Tuple2<K,V>> other)	Returns this Traversable if it is non-empty; otherwise, returns the given alternative.
SortedMap<K,V>	orElse(@NonNull Supplier<? extends Iterable<? extends Tuple2<K,V>>> supplier)	Returns this Traversable if it is non-empty; otherwise, returns the result of evaluating the given supplier.
Tuple2<? extends SortedMap<K,V>,? extends SortedMap<K,V>>	partition(@NonNull Predicate<? super Tuple2<K,V>> predicate)	Splits this Traversable into two partitions according to a predicate.
SortedMap<K,V>	peek(@NonNull Consumer<? super Tuple2<K,V>> action)	Performs the given action on the first element if this is an eager implementation.
SortedMap<K,V>	put(@NonNull Tuple2<? extends K,? extends V> entry)	Convenience method for put(entry._1, entry._2).
<U extends V> SortedMap<K,V>	put(@NonNull Tuple2<? extends K,U> entry, @NonNull BiFunction<? super V,? super U,? extends V> merge)	Convenience method for put(entry._1, entry._2, merge).
<U extends V> SortedMap<K,V>	put(K key, U value, @NonNull BiFunction<? super V,? super U,? extends V> merge)	Associates the specified value with the specified key in this map.
SortedMap<K,V>	put(K key, V value)	Associates the specified value with the specified key in this map.
SortedMap<K,V>	reject(@NonNull BiPredicate<? super K,? super V> predicate)	Returns a new Map consisting of all elements which do not satisfy the given predicate.
SortedMap<K,V>	reject(@NonNull Predicate<? super Tuple2<K,V>> predicate)	Returns a new traversable containing only the elements that do not satisfy the given predicate.
SortedMap<K,V>	rejectKeys(@NonNull Predicate<? super K> predicate)	Returns a new Map consisting of all elements with keys which do not satisfy the given predicate.
SortedMap<K,V>	rejectValues(@NonNull Predicate<? super V> predicate)	Returns a new Map consisting of all elements with values which do not satisfy the given predicate.
SortedMap<K,V>	remove(K key)	Removes the mapping for a key from this map if it is present.
SortedMap<K,V>	removeAll(@NonNull Iterable<? extends K> keys)	Removes the mapping for a key from this map if it is present.
SortedMap<K,V>	removeAll(@NonNull BiPredicate<? super K,? super V> predicate)	Deprecated.
SortedMap<K,V>	removeKeys(@NonNull Predicate<? super K> predicate)	Deprecated.
SortedMap<K,V>	removeValues(@NonNull Predicate<? super V> predicate)	Deprecated.
SortedMap<K,V>	replace(@NonNull Tuple2<K,V> currentElement, @NonNull Tuple2<K,V> newElement)	Replaces the first occurrence of currentElement with newElement, if it exists.
SortedMap<K,V>	replace(K key, V oldValue, V newValue)	Replaces the entry for the specified key only if currently mapped to the specified value.
SortedMap<K,V>	replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)	Replaces all occurrences of currentElement with newElement.
SortedMap<K,V>	replaceAll(@NonNull BiFunction<? super K,? super V,? extends V> function)	Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.
SortedMap<K,V>	replaceValue(K key, V value)	Replaces the entry for the specified key only if it is currently mapped to some value.
SortedMap<K,V>	retainAll(@NonNull Iterable<? extends Tuple2<K,V>> elements)	Retains only the elements from this Traversable that are contained in the given elements.
SortedMap<K,V>	scan(@NonNull Tuple2<K,V> zero, @NonNull BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)	Computes a prefix scan of the elements of this Traversable.
Iterator<? extends SortedMap<K,V>>	slideBy(@NonNull Function<? super Tuple2<K,V>,?> classifier)	Partitions this Traversable into consecutive non-overlapping windows according to a classification function.
Iterator<? extends SortedMap<K,V>>	sliding(int size)	Slides a window of a given size over this Traversable with a step size of 1.
Iterator<? extends SortedMap<K,V>>	sliding(int size, int step)	Slides a window of a specific size with a given step over this Traversable.
Tuple2<? extends SortedMap<K,V>,? extends SortedMap<K,V>>	span(@NonNull Predicate<? super Tuple2<K,V>> predicate)	Splits this Traversable into a prefix and remainder according to the given predicate.
SortedMap<K,V>	tail()	Returns a new Traversable without its first element.
Option<? extends SortedMap<K,V>>	tailOption()	Returns a new Traversable without its first element as an Option.
SortedMap<K,V>	take(int n)	Returns the first n elements of this Traversable, or all elements if n exceeds the length.
SortedMap<K,V>	takeRight(int n)	Returns the last n elements of this Traversable, or all elements if n exceeds the length.
SortedMap<K,V>	takeUntil(@NonNull Predicate<? super Tuple2<K,V>> predicate)	Takes elements from this Traversable until the given predicate holds for an element.
SortedMap<K,V>	takeWhile(@NonNull Predicate<? super Tuple2<K,V>> predicate)	Takes elements from this Traversable while the given predicate holds.
SortedMap<K,V>	toJavaMap()	Converts this Vavr Map to a java.util.Map while preserving characteristics like insertion order (LinkedHashMap) and sort order (SortedMap).

Methods inherited from interface io.vavr.collection.Foldable

fold, reduce, reduceOption

Methods inherited from interface io.vavr.Function1

andThen, arity, compose, compose1, curried, isMemoized, memoized, partial, reversed, tupled

Methods inherited from interface io.vavr.collection.Map

apply, asPartialFunction, collect, contains, containsKey, containsValue, flatMap, foldRight, forEach, get, getOrElse, hasDefiniteSize, isDefinedAt, isDistinct, isTraversableAgain, iterator, iterator, keysIterator, length, lift, map, mapTo, mapToVoid, scanLeft, scanRight, size, transform, unzip, unzip, unzip, unzip3, unzip3, values, valuesIterator, withDefault, withDefaultValue, zip, zipAll, zipWith, zipWithIndex, zipWithIndex

Methods inherited from interface io.vavr.collection.Ordered

comparator

Methods inherited from interface io.vavr.collection.Traversable

arrangeBy, average, containsAll, count, equals, existsUnique, find, findLast, foldLeft, forEachWithIndex, get, hashCode, head, headOption, isEmpty, isSequential, isSingleValued, lastOption, max, maxBy, maxBy, min, minBy, minBy, mkCharSeq, mkCharSeq, mkCharSeq, mkString, mkString, mkString, nonEmpty, product, reduceLeft, reduceLeftOption, reduceRight, reduceRightOption, single, singleOption, spliterator, sum

Methods inherited from interface io.vavr.Value

collect, collect, corresponds, eq, exists, forAll, forEach, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, getOrNull, isAsync, isLazy, out, out, stderr, stdout, stringPrefix, toArray, toCharSeq, toCompletableFuture, toEither, toEither, toInvalid, toInvalid, toJavaArray, toJavaArray, toJavaArray, toJavaCollection, toJavaList, toJavaList, toJavaMap, toJavaMap, toJavaMap, toJavaOptional, toJavaParallelStream, toJavaSet, toJavaSet, toJavaStream, toLeft, toLeft, toLinkedMap, toLinkedMap, toLinkedSet, toList, toMap, toMap, toOption, toPriorityQueue, toPriorityQueue, toQueue, toRight, toRight, toSet, toSortedMap, toSortedMap, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toStream, toString, toTree, toTree, toTry, toTry, toValid, toValid, toValidation, toValidation, toVector

Field Details

serialVersionUID

static final long serialVersionUID

The serial version UID for serialization.

See Also:

• Constant Field Values

Method Details

narrow

static <K,
V> SortedMap<K,V> narrow(SortedMap<? extends K,? extends V> sortedMap)

Narrows a widened SortedMap<? extends K, ? extends V> to SortedMap<K, V> by performing a type-safe cast. This is eligible because immutable/read-only collections are covariant.

CAUTION: If K is narrowed, the underlying Comparator might fail!

Type Parameters:

K - Key type

V - Value type

Parameters:

sortedMap - A SortedMap.

Returns:

the given sortedMap instance as narrowed type SortedMap<K, V>.

bimap

<K2,
V2> SortedMap<K2,V2> bimap(@NonNull Comparator<? super K2> keyComparator,
 @NonNull Function<? super K,? extends K2> keyMapper,
 Function<? super V,? extends V2> valueMapper)

Same as bimap(Function, Function), using a specific comparator for keys of the codomain of the given keyMapper.

Type Parameters:

K2 - key's component type of the map result

V2 - value's component type of the map result

Parameters:

keyComparator - A comparator for keys of type K2

keyMapper - a Function that maps the keys of type K to keys of type K2

valueMapper - a Function that the values of type V to values of type V2

Returns:

a new SortedMap

Throws:

NullPointerException - if keyMapper or valueMapper is null

flatMap

<K2,
V2> SortedMap<K2,V2> flatMap(@NonNull Comparator<? super K2> keyComparator,
 @NonNull BiFunction<? super K,? super V,? extends Iterable<Tuple2<K2,V2>>> mapper)

Same as flatMap(BiFunction) but using a specific comparator for values of the codomain of the given mapper.

Type Parameters:

K2 - New key type

V2 - New value type

Parameters:

keyComparator - A comparator for keys of type U

mapper - A function which maps key/value pairs to Iterables map entries

Returns:

A new Map instance containing mapped entries

map

<K2,
V2> SortedMap<K2,V2> map(@NonNull Comparator<? super K2> keyComparator,
 @NonNull BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)

Same as map(BiFunction), using a specific comparator for keys of the codomain of the given mapper.

Type Parameters:

K2 - key's component type of the map result

V2 - value's component type of the map result

Parameters:

keyComparator - A comparator for keys of type U

mapper - a Function that maps entries of type (K, V) to entries of type (K2, V2)

Returns:

a new SortedMap

Throws:

NullPointerException - if mapper is null

bimap

<K2,
V2> SortedMap<K2,V2> bimap(@NonNull Function<? super K,? extends K2> keyMapper,
 @NonNull Function<? super V,? extends V2> valueMapper)

Description copied from interface: Map

Maps this Map to a new Map with different component type by applying a function to its elements.

Specified by:

bimap in interface Map<K,V>

Type Parameters:

K2 - key's component type of the map result

V2 - value's component type of the map result

Parameters:

keyMapper - a Function that maps the keys of type K to keys of type K2

valueMapper - a Function that the values of type V to values of type V2

Returns:

a new Map

computeIfAbsent

Tuple2<V,? extends SortedMap<K,V>> computeIfAbsent(K key,
 @NonNull Function<? super K,? extends V> mappingFunction)

Description copied from interface: Map

If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map.

Specified by:

computeIfAbsent in interface Map<K,V>

Parameters:

key - key whose presence in this map is to be tested

mappingFunction - mapping function

Returns:

the Tuple2 of current or modified map and existing or computed value associated with the specified key

computeIfPresent

Tuple2<Option<V>,? extends SortedMap<K,V>> computeIfPresent(K key,
 @NonNull BiFunction<? super K,? super V,? extends V> remappingFunction)

Description copied from interface: Map

If the value for the specified key is present, attempts to compute a new mapping given the key and its current mapped value.

Specified by:

computeIfPresent in interface Map<K,V>

Parameters:

key - key whose presence in this map is to be tested

remappingFunction - remapping function

Returns:

the Tuple2 of current or modified map and the Some of the value associated with the specified key, or None if none

distinct

SortedMap<K,V> distinct()

Description copied from interface: Traversable

Returns a new Traversable containing the elements of this instance with all duplicates removed. Element equality is determined using equals.

Specified by:

distinct in interface Map<K,V>

Specified by:

distinct in interface Traversable<K>

Returns:

a new Traversable without duplicate elements

distinctBy

SortedMap<K,V> distinctBy(@NonNull Comparator<? super Tuple2<K,V>> comparator)

Description copied from interface: Traversable

Returns a new Traversable containing the elements of this instance without duplicates, as determined by the given comparator.

Specified by:

distinctBy in interface Map<K,V>

Specified by:

distinctBy in interface Traversable<K>

Parameters:

comparator - a comparator used to determine equality of elements

Returns:

a new Traversable with duplicates removed

distinctBy

<U> SortedMap<K,V> distinctBy(@NonNull Function<? super Tuple2<K,V>,? extends U> keyExtractor)

Description copied from interface: Traversable

Returns a new Traversable containing the elements of this instance without duplicates, based on keys extracted from elements using keyExtractor.

The first occurrence of each key is retained in the resulting sequence.

Specified by:

distinctBy in interface Map<K,V>

Specified by:

distinctBy in interface Traversable<K>

Type Parameters:

U - the type of key

Parameters:

keyExtractor - a function to extract keys for determining uniqueness

Returns:

a new Traversable with duplicates removed based on keys

drop

SortedMap<K,V> drop(int n)

Description copied from interface: Traversable

Returns a new Traversable without the first n elements, or an empty instance if this contains fewer than n elements.

Specified by:

drop in interface Map<K,V>

Specified by:

drop in interface Traversable<K>

Parameters:

n - the number of elements to drop

Returns:

a new instance excluding the first n elements

dropRight

SortedMap<K,V> dropRight(int n)

Description copied from interface: Traversable

Returns a new Traversable without the last n elements, or an empty instance if this contains fewer than n elements.

Specified by:

dropRight in interface Map<K,V>

Specified by:

dropRight in interface Traversable<K>

Parameters:

n - the number of elements to drop from the end

Returns:

a new instance excluding the last n elements

dropUntil

SortedMap<K,V> dropUntil(@NonNull Predicate<? super Tuple2<K,V>> predicate)

Description copied from interface: Traversable

Returns a new Traversable starting from the first element that satisfies the given predicate, dropping all preceding elements.

Specified by:

dropUntil in interface Map<K,V>

Specified by:

dropUntil in interface Traversable<K>

Parameters:

predicate - a condition tested on each element

Returns:

a new instance starting from the first element matching the predicate

dropWhile

SortedMap<K,V> dropWhile(@NonNull Predicate<? super Tuple2<K,V>> predicate)

Description copied from interface: Traversable

Returns a new Traversable starting from the first element that does not satisfy the given predicate, dropping all preceding elements.

This is equivalent to dropUntil(predicate.negate()), which is useful for method references that cannot be negated directly.

Specified by:

dropWhile in interface Map<K,V>

Specified by:

dropWhile in interface Traversable<K>

Parameters:

predicate - a condition tested on each element

Returns:

a new instance starting from the first element not matching the predicate

filter

SortedMap<K,V> filter(@NonNull Predicate<? super Tuple2<K,V>> predicate)

Description copied from interface: Traversable

Returns a new traversable containing only the elements that satisfy the given predicate.

Specified by:

filter in interface Map<K,V>

Specified by:

filter in interface Traversable<K>

Parameters:

predicate - the condition to test elements

Returns:

a traversable with elements matching the predicate

reject

SortedMap<K,V> reject(@NonNull Predicate<? super Tuple2<K,V>> predicate)

Description copied from interface: Traversable

Returns a new traversable containing only the elements that do not satisfy the given predicate.

This is equivalent to filter(predicate.negate()).

Specified by:

reject in interface Map<K,V>

Specified by:

reject in interface Traversable<K>

Parameters:

predicate - the condition to test elements

Returns:

a traversable with elements not matching the predicate

filter

SortedMap<K,V> filter(@NonNull BiPredicate<? super K,? super V> predicate)

Description copied from interface: Map

Returns a new Map consisting of all elements which satisfy the given predicate.

Specified by:

filter in interface Map<K,V>

Parameters:

predicate - the predicate used to test elements

Returns:

a new Map

reject

SortedMap<K,V> reject(@NonNull BiPredicate<? super K,? super V> predicate)

Description copied from interface: Map

Returns a new Map consisting of all elements which do not satisfy the given predicate.

Specified by:

reject in interface Map<K,V>

Parameters:

predicate - the predicate used to test elements

Returns:

a new Map

filterKeys

SortedMap<K,V> filterKeys(@NonNull Predicate<? super K> predicate)

Description copied from interface: Map

Returns a new Map consisting of all elements with keys which satisfy the given predicate.

Specified by:

filterKeys in interface Map<K,V>

Parameters:

predicate - the predicate used to test keys of elements

Returns:

a new Map

rejectKeys

SortedMap<K,V> rejectKeys(@NonNull Predicate<? super K> predicate)

Description copied from interface: Map

Returns a new Map consisting of all elements with keys which do not satisfy the given predicate.

Specified by:

rejectKeys in interface Map<K,V>

Parameters:

predicate - the predicate used to test keys of elements

Returns:

a new Map

filterValues

SortedMap<K,V> filterValues(@NonNull Predicate<? super V> predicate)

Description copied from interface: Map

Returns a new Map consisting of all elements with values which satisfy the given predicate.

Specified by:

filterValues in interface Map<K,V>

Parameters:

predicate - the predicate used to test values of elements

Returns:

a new Map

rejectValues

SortedMap<K,V> rejectValues(@NonNull Predicate<? super V> predicate)

Description copied from interface: Map

Returns a new Map consisting of all elements with values which do not satisfy the given predicate.

Specified by:

rejectValues in interface Map<K,V>

Parameters:

predicate - the predicate used to test values of elements

Returns:

a new Map

removeAll

@Deprecated
SortedMap<K,V> removeAll(@NonNull BiPredicate<? super K,? super V> predicate)

Deprecated.

Description copied from interface: Map

Returns a new Map consisting of all elements which do not satisfy the given predicate.

Specified by:

removeAll in interface Map<K,V>

Parameters:

predicate - the predicate used to test elements

Returns:

a new Map

removeKeys

@Deprecated
SortedMap<K,V> removeKeys(@NonNull Predicate<? super K> predicate)

Deprecated.

Description copied from interface: Map

Returns a new Map consisting of all elements with keys which do not satisfy the given predicate.

Specified by:

removeKeys in interface Map<K,V>

Parameters:

predicate - the predicate used to test keys of elements

Returns:

a new Map

removeValues

@Deprecated
SortedMap<K,V> removeValues(@NonNull Predicate<? super V> predicate)

Deprecated.

Description copied from interface: Map

Returns a new Map consisting of all elements with values which do not satisfy the given predicate.

Specified by:

removeValues in interface Map<K,V>

Parameters:

predicate - the predicate used to test values of elements

Returns:

a new Map

flatMap

<K2,
V2> SortedMap<K2,V2> flatMap(@NonNull BiFunction<? super K,? super V,? extends Iterable<Tuple2<K2,V2>>> mapper)

Description copied from interface: Map

FlatMaps this Map to a new Map with different component type.

Specified by:

flatMap in interface Map<K,V>

Type Parameters:

K2 - key's component type of the mapped Map

V2 - value's component type of the mapped Map

Parameters:

mapper - A mapper

Returns:

A new Map.

groupBy

<C> Map<C,? extends SortedMap<K,V>> groupBy(@NonNull Function<? super Tuple2<K,V>,? extends C> classifier)

Description copied from interface: Traversable

Groups elements of this Traversable based on a classifier function.

Specified by:

groupBy in interface Map<K,V>

Specified by:

groupBy in interface Traversable<K>

Type Parameters:

C - The type of the group keys

Parameters:

classifier - A function that assigns each element to a group

Returns:

A map where each key corresponds to a group of elements

See Also:

• Traversable.arrangeBy(Function)

grouped

Iterator<? extends SortedMap<K,V>> grouped(int size)

Description copied from interface: Traversable

Splits this Traversable into consecutive blocks of the given size.

Let length be the number of elements in this Traversable:

• If empty, the resulting Iterator is empty.
• If size <= length, the resulting Iterator contains length / size blocks of size size and possibly a final smaller block of size length % size.
• If size > length, the resulting Iterator contains a single block of size length.

Examples:

 
 [].grouped(1) = []
 [].grouped(0) throws
 [].grouped(-1) throws
 [1,2,3,4].grouped(2) = [[1,2],[3,4]]
 [1,2,3,4,5].grouped(2) = [[1,2],[3,4],[5]]
 [1,2,3,4].grouped(5) = [[1,2,3,4]]
 
 

Note: grouped(size) is equivalent to sliding(size, size).

Specified by:

grouped in interface Map<K,V>

Specified by:

grouped in interface Traversable<K>

Parameters:

size - the block size; must be positive

Returns:

an Iterator over blocks of elements

init

SortedMap<K,V> init()

Description copied from interface: Traversable

Returns all elements of this Traversable except the last one.

This is the dual of Traversable.tail().

Specified by:

init in interface Map<K,V>

Specified by:

init in interface Traversable<K>

Returns:

a new instance containing all elements except the last

initOption

Option<? extends SortedMap<K,V>> initOption()

Description copied from interface: Traversable

Returns all elements of this Traversable except the last one, wrapped in an Option.

This is the dual of Traversable.tailOption().

Specified by:

initOption in interface Map<K,V>

Specified by:

initOption in interface Traversable<K>

Returns:

Some(traversable) if non-empty, or None if this Traversable is empty

isOrdered

default boolean isOrdered()

Description copied from interface: Traversable

Indicates whether this Traversable is ordered according to its natural or specified order.

Specified by:

isOrdered in interface Traversable<K>

Returns:

true if this Traversable is ordered, false otherwise

keySet

SortedSet<K> keySet()

Description copied from interface: Map

Returns the keys contained in this map.

Specified by:

keySet in interface Map<K,V>

Returns:

Set of the keys contained in this map.

last

default Tuple2<K,V> last()

Description copied from interface: Traversable

Returns the last element of this Traversable.

Specified by:

last in interface Traversable<K>

Returns:

the last element

map

<K2,
V2> SortedMap<K2,V2> map(@NonNull BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)

Description copied from interface: Map

Maps the entries of this Map to form a new Map.

Specified by:

map in interface Map<K,V>

Type Parameters:

K2 - key's component type of the map result

V2 - value's component type of the map result

Parameters:

mapper - a Function that maps entries of type (K, V) to entries of type (K2, V2)

Returns:

a new Map

mapKeys

<K2> SortedMap<K2,V> mapKeys(@NonNull Function<? super K,? extends K2> keyMapper)

Description copied from interface: Map

Maps the keys of this Map while preserving the corresponding values.

The size of the result map may be smaller if keyMapper maps two or more distinct keys to the same new key. In this case the value at the latest of the original keys is retained. Order of keys is predictable in TreeMap (by comparator) and LinkedHashMap (insertion-order) and not predictable in HashMap.

Specified by:

mapKeys in interface Map<K,V>

Type Parameters:

K2 - the new key type

Parameters:

keyMapper - a Function that maps keys of type V to keys of type V2

Returns:

a new Map

mapKeys

<K2> SortedMap<K2,V> mapKeys(@NonNull Function<? super K,? extends K2> keyMapper,
 @NonNull BiFunction<? super V,? super V,? extends V> valueMerge)

Description copied from interface: Map

Maps the keys of this Map while preserving the corresponding values and applying a value merge function on collisions.

The size of the result map may be smaller if keyMapper maps two or more distinct keys to the same new key. In this case the associated values will be combined using valueMerge.

Specified by:

mapKeys in interface Map<K,V>

Type Parameters:

K2 - the new key type

Parameters:

keyMapper - a Function that maps keys of type V to keys of type V2

valueMerge - a BiFunction that merges values

Returns:

a new Map

mapValues

<V2> SortedMap<K,V2> mapValues(@NonNull Function<? super V,? extends V2> valueMapper)

Description copied from interface: Map

Maps the values of this Map while preserving the corresponding keys.

Specified by:

mapValues in interface Map<K,V>

Type Parameters:

V2 - the new value type

Parameters:

valueMapper - a Function that maps values of type V to values of type V2

Returns:

a new Map

merge

SortedMap<K,V> merge(@NonNull Map<? extends K,? extends V> that)

Description copied from interface: Map

Creates a new map which by merging the entries of this map and that map.

If collisions occur, the value of this map is taken.

Specified by:

merge in interface Map<K,V>

Parameters:

that - the other map

Returns:

A merged map

merge

<U extends V> SortedMap<K,V> merge(@NonNull Map<? extends K,U> that,
 @NonNull BiFunction<? super V,? super U,? extends V> collisionResolution)

Description copied from interface: Map

Creates a new map which by merging the entries of this map and that map.

Uses the specified collision resolution function if two keys are the same. The collision resolution function will always take the first argument from this map and the second from that map.

Specified by:

merge in interface Map<K,V>

Type Parameters:

U - value type of that Map

Parameters:

that - the other map

collisionResolution - the collision resolution function

Returns:

A merged map

orElse

SortedMap<K,V> orElse(Iterable<? extends Tuple2<K,V>> other)

Description copied from interface: Traversable

Returns this Traversable if it is non-empty; otherwise, returns the given alternative.

Specified by:

orElse in interface Map<K,V>

Specified by:

orElse in interface Traversable<K>

Parameters:

other - an alternative Traversable to return if this is empty

Returns:

this Traversable if non-empty, otherwise other

orElse

SortedMap<K,V> orElse(@NonNull Supplier<? extends Iterable<? extends Tuple2<K,V>>> supplier)

Description copied from interface: Traversable

Returns this Traversable if it is non-empty; otherwise, returns the result of evaluating the given supplier.

Specified by:

orElse in interface Map<K,V>

Specified by:

orElse in interface Traversable<K>

Parameters:

supplier - a supplier of an alternative Traversable if this is empty

Returns:

this Traversable if non-empty, otherwise the result of supplier.get()

partition

Tuple2<? extends SortedMap<K,V>,? extends SortedMap<K,V>> partition(@NonNull Predicate<? super Tuple2<K,V>> predicate)

Description copied from interface: Traversable

Splits this Traversable into two partitions according to a predicate.

The first partition contains all elements that satisfy the predicate, and the second contains all elements that do not. The original iteration order is preserved.

Specified by:

partition in interface Map<K,V>

Specified by:

partition in interface Traversable<K>

Parameters:

predicate - a predicate used to classify elements

Returns:

a Tuple2 containing the two resulting Traversable instances

peek

SortedMap<K,V> peek(@NonNull Consumer<? super Tuple2<K,V>> action)

Description copied from interface: Value

Performs the given action on the first element if this is an eager implementation. Performs the given action on all elements (the first immediately, successive deferred), if this is a lazy implementation.

Specified by:

peek in interface Map<K,V>

Specified by:

peek in interface Traversable<K>

Specified by:

peek in interface Value<K>

Parameters:

action - The action that will be performed on the element(s).

Returns:

this instance

put

SortedMap<K,V> put(K key,
 V value)

Description copied from interface: Map

Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced by the specified value.

Specified by:

put in interface Map<K,V>

Parameters:

key - key with which the specified value is to be associated

value - value to be associated with the specified key

Returns:

A new Map containing these elements and that entry.

put

SortedMap<K,V> put(@NonNull Tuple2<? extends K,? extends V> entry)

Description copied from interface: Map

Convenience method for put(entry._1, entry._2).

Specified by:

put in interface Map<K,V>

Parameters:

entry - A Tuple2 containing the key and value

Returns:

A new Map containing these elements and that entry.

put

<U extends V> SortedMap<K,V> put(K key,
 U value,
 @NonNull BiFunction<? super V,? super U,? extends V> merge)

Description copied from interface: Map

Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the merge function is used to combine the previous value to the value to be inserted, and the result of that call is inserted in the map.

Specified by:

put in interface Map<K,V>

Type Parameters:

U - the value type

Parameters:

key - key with which the specified value is to be associated

value - value to be associated with the specified key

merge - function taking the old and new values and merging them.

Returns:

A new Map containing these elements and that entry.

put

<U extends V> SortedMap<K,V> put(@NonNull Tuple2<? extends K,U> entry,
 @NonNull BiFunction<? super V,? super U,? extends V> merge)

Description copied from interface: Map

Convenience method for put(entry._1, entry._2, merge).

Specified by:

put in interface Map<K,V>

Type Parameters:

U - the value type

Parameters:

entry - A Tuple2 containing the key and value

merge - function taking the old and new values and merging them.

Returns:

A new Map containing these elements and that entry.

remove

SortedMap<K,V> remove(K key)

Description copied from interface: Map

Removes the mapping for a key from this map if it is present.

Specified by:

remove in interface Map<K,V>

Parameters:

key - key whose mapping is to be removed from the map

Returns:

A new Map containing these elements without the entry specified by that key.

removeAll

SortedMap<K,V> removeAll(@NonNull Iterable<? extends K> keys)

Description copied from interface: Map

Removes the mapping for a key from this map if it is present.

Specified by:

removeAll in interface Map<K,V>

Parameters:

keys - keys are to be removed from the map

Returns:

A new Map containing these elements without the entries specified by that keys.

replace

SortedMap<K,V> replace(K key,
 V oldValue,
 V newValue)

Description copied from interface: Map

Replaces the entry for the specified key only if currently mapped to the specified value.

Specified by:

replace in interface Map<K,V>

Parameters:

key - the key of the element to be substituted.

oldValue - the expected current value that the key is currently mapped to

newValue - the new value to be associated with the key

Returns:

a new map containing key mapped to newValue if key was contained before and oldValue matched. The old map otherwise.

replace

SortedMap<K,V> replace(@NonNull Tuple2<K,V> currentElement,
 @NonNull Tuple2<K,V> newElement)

Description copied from interface: Traversable

Replaces the first occurrence of currentElement with newElement, if it exists.

Specified by:

replace in interface Map<K,V>

Specified by:

replace in interface Traversable<K>

Parameters:

currentElement - the element to be replaced

newElement - the replacement element

Returns:

a new Traversable with the first occurrence of currentElement replaced by newElement

replaceValue

SortedMap<K,V> replaceValue(K key,
 V value)

Description copied from interface: Map

Replaces the entry for the specified key only if it is currently mapped to some value.

Specified by:

replaceValue in interface Map<K,V>

Parameters:

key - the key of the element to be substituted.

value - the new value to be associated with the key

Returns:

a new map containing key mapped to value if key was contained before. The old map otherwise.

replaceAll

SortedMap<K,V> replaceAll(@NonNull BiFunction<? super K,? super V,? extends V> function)

Description copied from interface: Map

Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.

Specified by:

replaceAll in interface Map<K,V>

Parameters:

function - function transforming key and current value to a new value

Returns:

a new map with the same keySet but transformed values.

replaceAll

SortedMap<K,V> replaceAll(@NonNull Tuple2<K,V> currentElement,
 Tuple2<K,V> newElement)

Description copied from interface: Traversable

Replaces all occurrences of currentElement with newElement.

Specified by:

replaceAll in interface Map<K,V>

Specified by:

replaceAll in interface Traversable<K>

Parameters:

currentElement - the element to be replaced

newElement - the replacement element

Returns:

a new Traversable with all occurrences of currentElement replaced by newElement

retainAll

SortedMap<K,V> retainAll(@NonNull Iterable<? extends Tuple2<K,V>> elements)

Description copied from interface: Traversable

Retains only the elements from this Traversable that are contained in the given elements.

Specified by:

retainAll in interface Map<K,V>

Specified by:

retainAll in interface Traversable<K>

Parameters:

elements - the elements to keep

Returns:

a new Traversable containing only the elements present in elements, in their original order

scan

SortedMap<K,V> scan(@NonNull Tuple2<K,V> zero,
 @NonNull BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)

Description copied from interface: Traversable

Computes a prefix scan of the elements of this Traversable.

The neutral element zero may be applied more than once.

Specified by:

scan in interface Map<K,V>

Specified by:

scan in interface Traversable<K>

Parameters:

zero - the neutral element for the operator

operation - an associative binary operator

Returns:

a new Traversable containing the prefix scan of the elements

slideBy

Iterator<? extends SortedMap<K,V>> slideBy(@NonNull Function<? super Tuple2<K,V>,?> classifier)

Description copied from interface: Traversable

Partitions this Traversable into consecutive non-overlapping windows according to a classification function.

Each window contains elements with the same class, as determined by classifier. Two consecutive elements belong to the same window only if classifier returns equal values for both. Otherwise, the current window ends and a new window begins with the next element.

Examples:

 [].slideBy(Function.identity()) = []
 [1,2,3,4,4,5].slideBy(Function.identity()) = [[1],[2],[3],[4,4],[5]]
 [1,2,3,10,12,5,7,20,29].slideBy(x -> x / 10) = [[1,2,3],[10,12],[5,7],[20,29]]
 

Specified by:

slideBy in interface Map<K,V>

Specified by:

slideBy in interface Traversable<K>

Parameters:

classifier - A function classifying elements into groups

Returns:

An Iterator of windows (grouped elements)

sliding

Iterator<? extends SortedMap<K,V>> sliding(int size)

Description copied from interface: Traversable

Slides a window of a given size over this Traversable with a step size of 1.

This is equivalent to calling Traversable.sliding(int, int) with a step size of 1.

Specified by:

sliding in interface Map<K,V>

Specified by:

sliding in interface Traversable<K>

Parameters:

size - a positive window size

Returns:

An Iterator of windows, each containing up to size elements

sliding

Iterator<? extends SortedMap<K,V>> sliding(int size,
 int step)

Description copied from interface: Traversable

Slides a window of a specific size with a given step over this Traversable.

Examples:

 [].sliding(1, 1) = []
 [1,2,3,4,5].sliding(2, 3) = [[1,2],[4,5]]
 [1,2,3,4,5].sliding(2, 4) = [[1,2],[5]]
 [1,2,3,4,5].sliding(2, 5) = [[1,2]]
 [1,2,3,4].sliding(5, 3) = [[1,2,3,4],[4]]
 

Specified by:

sliding in interface Map<K,V>

Specified by:

sliding in interface Traversable<K>

Parameters:

size - a positive window size

step - a positive step size

Returns:

an Iterator of windows with the given size and step

span

Tuple2<? extends SortedMap<K,V>,? extends SortedMap<K,V>> span(@NonNull Predicate<? super Tuple2<K,V>> predicate)

Description copied from interface: Traversable

Splits this Traversable into a prefix and remainder according to the given predicate.

The first element of the returned Tuple is the longest prefix of elements satisfying predicate, and the second element is the remaining elements.

Specified by:

span in interface Map<K,V>

Specified by:

span in interface Traversable<K>

Parameters:

predicate - a predicate used to determine the prefix

Returns:

a Tuple containing the prefix and remainder

tail

SortedMap<K,V> tail()

Description copied from interface: Traversable

Returns a new Traversable without its first element.

Specified by:

tail in interface Map<K,V>

Specified by:

tail in interface Traversable<K>

Returns:

a new Traversable containing all elements except the first

tailOption

Option<? extends SortedMap<K,V>> tailOption()

Description copied from interface: Traversable

Returns a new Traversable without its first element as an Option.

Specified by:

tailOption in interface Map<K,V>

Specified by:

tailOption in interface Traversable<K>

Returns:

Some(traversable) if non-empty, otherwise None

take

SortedMap<K,V> take(int n)

Description copied from interface: Traversable

Returns the first n elements of this Traversable, or all elements if n exceeds the length.

Equivalent to sublist(0, max(0, min(length(), n))), but safe for n < 0 or n > length().

If n < 0, an empty instance is returned. If n > length(), the full instance is returned.

Specified by:

take in interface Map<K,V>

Specified by:

take in interface Traversable<K>

Parameters:

n - the number of elements to take

Returns:

a new Traversable containing the first n elements

takeRight

SortedMap<K,V> takeRight(int n)

Description copied from interface: Traversable

Returns the last n elements of this Traversable, or all elements if n exceeds the length.

Equivalent to sublist(max(0, length() - n), length()), but safe for n < 0 or n > length().

If n < 0, an empty instance is returned. If n > length(), the full instance is returned.

Specified by:

takeRight in interface Map<K,V>

Specified by:

takeRight in interface Traversable<K>

Parameters:

n - the number of elements to take from the end

Returns:

a new Traversable containing the last n elements

takeUntil

SortedMap<K,V> takeUntil(@NonNull Predicate<? super Tuple2<K,V>> predicate)

Description copied from interface: Traversable

Takes elements from this Traversable until the given predicate holds for an element.

Equivalent to takeWhile(predicate.negate()), but useful when using method references that cannot be negated directly.

Specified by:

takeUntil in interface Map<K,V>

Specified by:

takeUntil in interface Traversable<K>

Parameters:

predicate - a condition tested sequentially on the elements

Returns:

a new Traversable containing all elements before the first one that satisfies the predicate

takeWhile

SortedMap<K,V> takeWhile(@NonNull Predicate<? super Tuple2<K,V>> predicate)

Description copied from interface: Traversable

Takes elements from this Traversable while the given predicate holds.

Specified by:

takeWhile in interface Map<K,V>

Specified by:

takeWhile in interface Traversable<K>

Parameters:

predicate - a condition tested sequentially on the elements

Returns:

a new Traversable containing all elements up to (but not including) the first one that does not satisfy the predicate

toJavaMap

SortedMap<K,V> toJavaMap()

Description copied from interface: Map

Converts this Vavr Map to a java.util.Map while preserving characteristics like insertion order (LinkedHashMap) and sort order (SortedMap).

Specified by:

toJavaMap in interface Map<K,V>

Returns:

a new java.util.Map instance