Package io.vavr.collection

Class TreeMap<K,V>

java.lang.Object

io.vavr.collection.TreeMap<K,V>

Type Parameters:

K - the type of keys maintained by this map

V - the type of mapped values

All Implemented Interfaces:

Foldable<Tuple2<K,V>>, Map<K,V>, Ordered<K>, SortedMap<K,V>, Traversable<Tuple2<K,V>>, Function1<K,V>, PartialFunction<K,V>, Value<Tuple2<K,V>>, java.io.Serializable, java.lang.Iterable<Tuple2<K,V>>, java.util.function.Function<K,V>

public final class TreeMap<K,V>
extends java.lang.Object
implements SortedMap<K,V>, java.io.Serializable

An immutable SortedMap implementation backed by a Red-Black tree.

Provides efficient sorted key access and typical map operations in a functional style.

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static interface	TreeMap.EntryComparator<K,V>

Field Summary

Fields

Modifier and Type	Field	Description
private RedBlackTree<Tuple2<K,V>>	entries
private static long	serialVersionUID

Constructor Summary

Constructors

Modifier	Constructor	Description
private	TreeMap(RedBlackTree<Tuple2<K,V>> entries)

Method Summary

Modifier and Type	Method	Description
private static <K,K2,V,V2> TreeMap<K2,V2>	bimap(@NonNull TreeMap<K,V> map, @NonNull TreeMap.EntryComparator<K2,V2> entryComparator, java.util.function.Function<? super K,? extends K2> keyMapper, java.util.function.Function<? super V,? extends V2> valueMapper)
<K2,V2> TreeMap<K2,V2>	bimap(@NonNull java.util.Comparator<? super K2> keyComparator, @NonNull java.util.function.Function<? super K,? extends K2> keyMapper, java.util.function.Function<? super V,? extends V2> valueMapper)	Same as SortedMap.bimap(Function, Function), using a specific comparator for keys of the codomain of the given keyMapper.
<K2,V2> TreeMap<K2,V2>	bimap(@NonNull java.util.function.Function<? super K,? extends K2> keyMapper, @NonNull java.util.function.Function<? super V,? extends V2> valueMapper)	Maps this Map to a new Map with different component type by applying a function to its elements.
static <K extends java.lang.Comparable<? super K>,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.
static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	collector(@NonNull java.util.Comparator<? super K> keyComparator)	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.
static <K,V,T extends V> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>>	collector(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.util.function.Function<? super T,? extends K> keyMapper)	Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeMap.
static <K,V,T> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>>	collector(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.util.function.Function<? super T,? extends K> keyMapper, java.util.function.Function<? super T,? extends V> valueMapper)	Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeMap.
static <K extends java.lang.Comparable<? super K>,V,T extends V> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>>	collector(@NonNull java.util.function.Function<? super T,? extends K> keyMapper)	Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeMap.
static <K extends java.lang.Comparable<? super K>,V,T> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>>	collector(@NonNull java.util.function.Function<? super T,? extends K> keyMapper, @NonNull java.util.function.Function<? super T,? extends V> valueMapper)	Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeMap.
java.util.Comparator<K>	comparator()	Returns the comparator that governs the ordering of elements in this collection.
Tuple2<V,TreeMap<K,V>>	computeIfAbsent(K key, @NonNull java.util.function.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>,TreeMap<K,V>>	computeIfPresent(K key, @NonNull java.util.function.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.
boolean	containsKey(K key)	Returns true if this map contains a mapping for the specified key.
private static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	createCollector(@NonNull TreeMap.EntryComparator<K,V> entryComparator)
private static <K,V,T> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>>	createCollector(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull java.util.function.Function<? super T,? extends K> keyMapper, @NonNull java.util.function.Function<? super T,? extends V> valueMapper)
private TreeMap<K,V>	createFromEntries(@NonNull java.lang.Iterable<Tuple2<K,V>> tuples)
private static <K,V> TreeMap<K,V>	createFromMap(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull java.util.Map<? extends K,? extends V> map)
private static <K,V> TreeMap<K,V>	createFromMapEntries(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull java.util.Map.Entry<? extends K,? extends V> @NonNull ... entries)
private static <K,V> TreeMap<K,V>	createFromPairs(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull java.lang.Object @NonNull ... pairs)
private static <K,V> TreeMap<K,V>	createFromTuple(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull Tuple2<? extends K,? extends V> entry)
private static <K,V> TreeMap<K,V>	createFromTuples(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)
private static <K,V> TreeMap<K,V>	createTreeMap(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)
private static <K,K2,V,V2> TreeMap<K2,V2>	createTreeMap(@NonNull TreeMap.EntryComparator<K2,V2> entryComparator, @NonNull java.lang.Iterable<Tuple2<K,V>> entries, java.util.function.Function<Tuple2<K,V>,Tuple2<K2,V2>> entryMapper)
TreeMap<K,V>	distinct()	Returns a new Traversable containing the elements of this instance with all duplicates removed.
TreeMap<K,V>	distinctBy(@NonNull java.util.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> TreeMap<K,V>	distinctBy(@NonNull java.util.function.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.
TreeMap<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.
TreeMap<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.
TreeMap<K,V>	dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)	Returns a new Traversable starting from the first element that satisfies the given predicate, dropping all preceding elements.
TreeMap<K,V>	dropWhile(@NonNull java.util.function.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.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	empty()	Returns the empty TreeMap.
static <K,V> TreeMap<K,V>	empty(@NonNull java.util.Comparator<? super K> keyComparator)	Returns the empty TreeMap using the given key comparator.
private TreeMap<K,V>	emptyInstance()
boolean	equals(java.lang.Object o)	Determines whether this collection is equal to the given object.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	fill(int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)	Returns a TreeMap containing tuples returned by n calls to a given Supplier s.
static <K,V> TreeMap<K,V>	fill(@NonNull java.util.Comparator<? super K> keyComparator, int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)	Returns a TreeMap containing tuples returned by n calls to a given Supplier s.
TreeMap<K,V>	filter(@NonNull java.util.function.BiPredicate<? super K,? super V> predicate)	Returns a new Map consisting of all elements which satisfy the given predicate.
TreeMap<K,V>	filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)	Returns a new traversable containing only the elements that satisfy the given predicate.
TreeMap<K,V>	filterKeys(@NonNull java.util.function.Predicate<? super K> predicate)	Returns a new Map consisting of all elements with keys which satisfy the given predicate.
TreeMap<K,V>	filterValues(@NonNull java.util.function.Predicate<? super V> predicate)	Returns a new Map consisting of all elements with values which satisfy the given predicate.
private static <K,V,K2,V2> TreeMap<K2,V2>	flatMap(@NonNull TreeMap<K,V> map, @NonNull TreeMap.EntryComparator<K2,V2> entryComparator, java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> TreeMap<K2,V2>	flatMap(@NonNull java.util.Comparator<? super K2> keyComparator, @NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)	Same as SortedMap.flatMap(BiFunction) but using a specific comparator for values of the codomain of the given mapper.
<K2,V2> TreeMap<K2,V2>	flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)	FlatMaps this Map to a new Map with different component type.
Option<V>	get(K key)	Returns the Some of value to which the specified key is mapped, or None if this map contains no mapping for the key.
V	getOrElse(K key, V defaultValue)	Returns the value associated with a key, or a default value if the key is not contained in the map.
<C> Map<C,TreeMap<K,V>>	groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)	Groups elements of this Traversable based on a classifier function.
Iterator<TreeMap<K,V>>	grouped(int size)	Splits this Traversable into consecutive blocks of the given size.
int	hashCode()	Returns the hash code of this collection.
Tuple2<K,V>	head()	Returns the first element of this non-empty Traversable.
TreeMap<K,V>	init()	Returns all elements of this Traversable except the last one.
Option<TreeMap<K,V>>	initOption()	Returns all elements of this Traversable except the last one, wrapped in an Option.
boolean	isAsync()	An TreeMap's value is computed synchronously.
boolean	isEmpty()	Checks if this Traversable contains no elements.
boolean	isLazy()	An TreeMap's value is computed eagerly.
@NonNull Iterator<Tuple2<K,V>>	iterator()	Returns an iterator over the elements of this Traversable, implemented via Traversable.head() and Traversable.tail().
SortedSet<K>	keySet()	Returns the keys contained in this map.
Tuple2<K,V>	last()	Returns the last element of this Traversable.
private static <K,K2,V,V2> TreeMap<K2,V2>	map(@NonNull TreeMap<K,V> map, @NonNull TreeMap.EntryComparator<K2,V2> entryComparator, java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
<K2,V2> TreeMap<K2,V2>	map(@NonNull java.util.Comparator<? super K2> keyComparator, @NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)	Same as SortedMap.map(BiFunction), using a specific comparator for keys of the codomain of the given mapper.
<K2,V2> TreeMap<K2,V2>	map(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)	Maps the entries of this Map to form a new Map.
<K2> TreeMap<K2,V>	mapKeys(@NonNull java.util.function.Function<? super K,? extends K2> keyMapper)	Maps the keys of this Map while preserving the corresponding values.
<K2> TreeMap<K2,V>	mapKeys(@NonNull java.util.function.Function<? super K,? extends K2> keyMapper, @NonNull java.util.function.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.
<W> TreeMap<K,W>	mapValues(@NonNull java.util.function.Function<? super V,? extends W> valueMapper)	Maps the values of this Map while preserving the corresponding keys.
TreeMap<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> TreeMap<K,V>	merge(@NonNull Map<? extends K,U> that, @NonNull java.util.function.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> TreeMap<K,V>	narrow(TreeMap<? extends K,? extends V> treeMap)	Narrows a TreeMap<? extends K, ? extends V> to TreeMap<K, V> via a type-safe cast.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(@NonNull Tuple2<? extends K,? extends V> entry)	Returns a singleton TreeMap, i.e.
static <K,V> TreeMap<K,V>	of(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull Tuple2<? extends K,? extends V> entry)	Returns a singleton TreeMap, i.e.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K key, V value)	Returns a singleton TreeMap, i.e.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2, K k3, V v3)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	of(java.util.Comparator<? super K> keyComparator, K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K key, V value)	Returns a singleton TreeMap, i.e.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)	Creates a TreeMap of the given list of key-value pairs.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)	Creates a TreeMap of the given list of key-value pairs.
static <K,V> TreeMap<K,V>	ofAll(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.util.Map<? extends K,? extends V> map)	Returns a TreeMap, from a source java.util.Map.
static <T,K,V> TreeMap<K,V>	ofAll(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)	Returns a TreeMap, from entries mapped from stream.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	ofAll(@NonNull java.util.Map<? extends K,? extends V> map)	Returns a TreeMap, from a source java.util.Map.
static <T,K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	ofAll(@NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,? extends K> keyMapper, @NonNull java.util.function.Function<? super T,? extends V> valueMapper)	Returns a TreeMap, from entries mapped from stream.
static <T,K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	ofAll(@NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)	Returns a TreeMap, from entries mapped from stream.
static <T,K,V> TreeMap<K,V>	ofAll(java.util.Comparator<? super K> keyComparator, @NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,? extends K> keyMapper, @NonNull java.util.function.Function<? super T,? extends V> valueMapper)	Returns a TreeMap, from entries mapped from stream.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	ofEntries(@NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)	Creates a TreeMap of the given entries using the natural key comparator.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	ofEntries(@NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)	Creates a TreeMap of the given entries.
static <K,V> TreeMap<K,V>	ofEntries(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)	Creates a TreeMap of the given entries using the given key comparator.
static <K,V> TreeMap<K,V>	ofEntries(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)	Creates a TreeMap of the given entries.
static <K,V> TreeMap<K,V>	ofEntries(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.util.Map.Entry<? extends K,? extends V> @NonNull ... entries)	Creates a TreeMap of the given entries using the given key comparator.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	ofEntries(@NonNull java.util.Map.Entry<? extends K,? extends V> @NonNull ... entries)	Creates a TreeMap of the given entries using the natural key comparator.
TreeMap<K,V>	orElse(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> other)	Returns this TreeMap if it is nonempty, otherwise TreeMap created from iterable, using existing comparator.
TreeMap<K,V>	orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)	Returns this TreeMap if it is nonempty, otherwise TreeMap created from result of evaluating supplier, using existing comparator.
Tuple2<TreeMap<K,V>,TreeMap<K,V>>	partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)	Splits this Traversable into two partitions according to a predicate.
TreeMap<K,V>	peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)	Performs the given action on the first element if this is an eager implementation.
TreeMap<K,V>	put(@NonNull Tuple2<? extends K,? extends V> entry)	Convenience method for put(entry._1, entry._2).
<U extends V> TreeMap<K,V>	put(@NonNull Tuple2<? extends K,U> entry, @NonNull java.util.function.BiFunction<? super V,? super U,? extends V> merge)	Convenience method for put(entry._1, entry._2, merge).
<U extends V> TreeMap<K,V>	put(K key, U value, @NonNull java.util.function.BiFunction<? super V,? super U,? extends V> merge)	Associates the specified value with the specified key in this map.
TreeMap<K,V>	put(K key, V value)	Associates the specified value with the specified key in this map.
TreeMap<K,V>	reject(@NonNull java.util.function.BiPredicate<? super K,? super V> predicate)	Returns a new Map consisting of all elements which do not satisfy the given predicate.
TreeMap<K,V>	reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)	Returns a new traversable containing only the elements that do not satisfy the given predicate.
TreeMap<K,V>	rejectKeys(@NonNull java.util.function.Predicate<? super K> predicate)	Returns a new Map consisting of all elements with keys which do not satisfy the given predicate.
TreeMap<K,V>	rejectValues(@NonNull java.util.function.Predicate<? super V> predicate)	Returns a new Map consisting of all elements with values which do not satisfy the given predicate.
TreeMap<K,V>	remove(K key)	Removes the mapping for a key from this map if it is present.
TreeMap<K,V>	removeAll(@NonNull java.lang.Iterable<? extends K> keys)	Removes the mapping for a key from this map if it is present.
TreeMap<K,V>	removeAll(@NonNull java.util.function.BiPredicate<? super K,? super V> predicate)	Deprecated.
TreeMap<K,V>	removeKeys(@NonNull java.util.function.Predicate<? super K> predicate)	Deprecated.
TreeMap<K,V>	removeValues(@NonNull java.util.function.Predicate<? super V> predicate)	Deprecated.
TreeMap<K,V>	replace(@NonNull Tuple2<K,V> currentElement, @NonNull Tuple2<K,V> newElement)	Replaces the first occurrence of currentElement with newElement, if it exists.
TreeMap<K,V>	replace(K key, V oldValue, V newValue)	Replaces the entry for the specified key only if currently mapped to the specified value.
TreeMap<K,V>	replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)	Replaces all occurrences of currentElement with newElement.
TreeMap<K,V>	replaceAll(@NonNull java.util.function.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.
TreeMap<K,V>	replaceValue(K key, V value)	Replaces the entry for the specified key only if it is currently mapped to some value.
TreeMap<K,V>	retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)	Retains only the elements from this Traversable that are contained in the given elements.
TreeMap<K,V>	scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)	Computes a prefix scan of the elements of this Traversable.
int	size()	Returns the number of elements in this Traversable.
Iterator<TreeMap<K,V>>	slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)	Partitions this Traversable into consecutive non-overlapping windows according to a classification function.
Iterator<TreeMap<K,V>>	sliding(int size)	Slides a window of a given size over this Traversable with a step size of 1.
Iterator<TreeMap<K,V>>	sliding(int size, int step)	Slides a window of a specific size with a given step over this Traversable.
Tuple2<TreeMap<K,V>,TreeMap<K,V>>	span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)	Splits this Traversable into a prefix and remainder according to the given predicate.
java.lang.String	stringPrefix()	Returns the name of this Value type, which is used by toString().
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	tabulate(int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V>> f)	Returns a TreeMap containing n values of a given Function f over a range of integer values from 0 to n - 1.
static <K,V> TreeMap<K,V>	tabulate(java.util.Comparator<? super K> keyComparator, int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V>> f)	Returns a TreeMap containing n values of a given Function f over a range of integer values from 0 to n - 1.
TreeMap<K,V>	tail()	Returns a new Traversable without its first element.
Option<TreeMap<K,V>>	tailOption()	Returns a new Traversable without its first element as an Option.
TreeMap<K,V>	take(int n)	Returns the first n elements of this Traversable, or all elements if n exceeds the length.
TreeMap<K,V>	takeRight(int n)	Returns the last n elements of this Traversable, or all elements if n exceeds the length.
TreeMap<K,V>	takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)	Takes elements from this Traversable until the given predicate holds for an element.
TreeMap<K,V>	takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)	Takes elements from this Traversable while the given predicate holds.
java.util.TreeMap<K,V>	toJavaMap()	Converts this Vavr Map to a java.util.Map while preserving characteristics like insertion order (LinkedHashMap) and sort order (SortedMap).
java.lang.String	toString()	Clarifies that values have a proper toString() method implemented.
Seq<V>	values()	Returns a new Seq that contains the values of this Map.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

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, containsValue, flatMap, foldRight, forEach, hasDefiniteSize, isDefinedAt, isDistinct, isTraversableAgain, iterator, keysIterator, length, lift, map, mapTo, mapToVoid, scanLeft, scanRight, transform, unzip, unzip, unzip, unzip3, unzip3, valuesIterator, withDefault, withDefaultValue, zip, zipAll, zipWith, zipWithIndex, zipWithIndex

Methods inherited from interface io.vavr.collection.SortedMap

isOrdered

Methods inherited from interface io.vavr.collection.Traversable

arrangeBy, average, containsAll, count, existsUnique, find, findLast, foldLeft, forEachWithIndex, get, headOption, 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, out, out, stderr, stdout, 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, toTree, toTree, toTry, toTry, toValid, toValid, toValidation, toValidation, toVector

Field Detail

serialVersionUID

private static final long serialVersionUID

See Also:

Constant Field Values

entries

private final RedBlackTree<Tuple2<K,V>> entries

Constructor Detail

TreeMap

private TreeMap(RedBlackTree<Tuple2<K,V>> entries)

Method Detail

collector

public static <K extends java.lang.Comparable<? super K>,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>> collector()

Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.

The natural comparator is used to compare TreeMap keys.

Type Parameters:

K - The key type

V - The value type

Returns:

A TreeMap Collector.

collector

public static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>> collector(@NonNull java.util.Comparator<? super K> keyComparator)

Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

Returns:

A TreeMap Collector.

collector

public static <K extends java.lang.Comparable<? super K>,V,T extends V> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>> collector(@NonNull java.util.function.Function<? super T,? extends K> keyMapper)

Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeMap.

The natural comparator is used to compare TreeMap keys.

Type Parameters:

K - The key type

V - The value type

T - Initial Stream elements type

Parameters:

keyMapper - The key mapper

Returns:

A TreeMap Collector.

collector

public static <K extends java.lang.Comparable<? super K>,V,T> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>> collector(@NonNull java.util.function.Function<? super T,? extends K> keyMapper,
                                                                                                                                                                        @NonNull java.util.function.Function<? super T,? extends V> valueMapper)

Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeMap.

The natural comparator is used to compare TreeMap keys.

Type Parameters:

K - The key type

V - The value type

T - Initial Stream elements type

Parameters:

keyMapper - The key mapper

valueMapper - The value mapper

Returns:

A TreeMap Collector.

collector

public static <K,V,T extends V> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>> collector(@NonNull java.util.Comparator<? super K> keyComparator,
                                                                                                                                          @NonNull java.util.function.Function<? super T,? extends K> keyMapper)

Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeMap.

Type Parameters:

K - The key type

V - The value type

T - Initial Stream elements type

Parameters:

keyMapper - The key mapper

keyComparator - The comparator used to sort the entries by their key.

Returns:

A TreeMap Collector.

collector

public static <K,V,T> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>> collector(@NonNull java.util.Comparator<? super K> keyComparator,
                                                                                                                                @NonNull java.util.function.Function<? super T,? extends K> keyMapper,
                                                                                                                                java.util.function.Function<? super T,? extends V> valueMapper)

Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeMap.

Type Parameters:

K - The key type

V - The value type

T - Initial Stream elements type

Parameters:

keyMapper - The key mapper

valueMapper - The value mapper

keyComparator - The comparator used to sort the entries by their key.

Returns:

A TreeMap Collector.

empty

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> empty()

Returns the empty TreeMap. The underlying key comparator is the natural comparator of K.

Type Parameters:

K - The key type

V - The value type

Returns:

A new empty TreeMap.

empty

public static <K,V> TreeMap<K,V> empty(@NonNull java.util.Comparator<? super K> keyComparator)

Returns the empty TreeMap using the given key comparator.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

Returns:

A new empty TreeMap.

narrow

public static <K,V> TreeMap<K,V> narrow(TreeMap<? extends K,? extends V> treeMap)

Narrows a TreeMap<? extends K, ? extends V> to TreeMap<K, V> via a type-safe cast. Safe here because the map is immutable and no elements can be added that would violate the type (covariance)

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

Type Parameters:

K - the target key type

V - the target value type

Parameters:

treeMap - the map to narrow

Returns:

the same map viewed as TreeMap<K, V>

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(@NonNull Tuple2<? extends K,? extends V> entry)

Returns a singleton TreeMap, i.e. a TreeMap of one entry. The underlying key comparator is the natural comparator of K.

Type Parameters:

K - The key type

V - The value type

Parameters:

entry - A map entry.

Returns:

A new TreeMap containing the given entry.

of

public static <K,V> TreeMap<K,V> of(@NonNull java.util.Comparator<? super K> keyComparator,
                                                @NonNull Tuple2<? extends K,? extends V> entry)

Returns a singleton TreeMap, i.e. a TreeMap of one entry using a specific key comparator.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

entry - A map entry.

Returns:

A new TreeMap containing the given entry.

ofAll

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> ofAll(@NonNull java.util.Map<? extends K,? extends V> map)

Returns a TreeMap, from a source java.util.Map.

Type Parameters:

K - The key type

V - The value type

Parameters:

map - A map

Returns:

A new Map containing the given map

ofAll

public static <T,K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> ofAll(@NonNull java.util.stream.Stream<? extends T> stream,
                                                                                                   @NonNull java.util.function.Function<? super T,? extends K> keyMapper,
                                                                                                   @NonNull java.util.function.Function<? super T,? extends V> valueMapper)

Returns a TreeMap, from entries mapped from stream.

Type Parameters:

T - The stream element type

K - The key type

V - The value type

Parameters:

stream - the source stream

keyMapper - the key mapper

valueMapper - the value mapper

Returns:

A new Map

ofAll

public static <T,K,V> TreeMap<K,V> ofAll(java.util.Comparator<? super K> keyComparator,
                                                           @NonNull java.util.stream.Stream<? extends T> stream,
                                                           @NonNull java.util.function.Function<? super T,? extends K> keyMapper,
                                                           @NonNull java.util.function.Function<? super T,? extends V> valueMapper)

Returns a TreeMap, from entries mapped from stream.

Type Parameters:

T - The stream element type

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

stream - the source stream

keyMapper - the key mapper

valueMapper - the value mapper

Returns:

A new Map

ofAll

public static <T,K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> ofAll(@NonNull java.util.stream.Stream<? extends T> stream,
                                                                                                   @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)

Returns a TreeMap, from entries mapped from stream.

Type Parameters:

T - The stream element type

K - The key type

V - The value type

Parameters:

stream - the source stream

entryMapper - the entry mapper

Returns:

A new Map

ofAll

public static <T,K,V> TreeMap<K,V> ofAll(@NonNull java.util.Comparator<? super K> keyComparator,
                                                           @NonNull java.util.stream.Stream<? extends T> stream,
                                                           @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)

Returns a TreeMap, from entries mapped from stream.

Type Parameters:

T - The stream element type

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

stream - the source stream

entryMapper - the entry mapper

Returns:

A new Map

ofAll

public static <K,V> TreeMap<K,V> ofAll(@NonNull java.util.Comparator<? super K> keyComparator,
                                                   @NonNull java.util.Map<? extends K,? extends V> map)

Returns a TreeMap, from a source java.util.Map.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

map - A map

Returns:

A new Map containing the given map

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K key,
                                                                                        V value)

Returns a singleton TreeMap, i.e. a TreeMap of one element.

Type Parameters:

K - The key type

V - The value type

Parameters:

key - A singleton map key.

value - A singleton map value.

Returns:

A new Map containing the given entry

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

Returns:

A new Map containing the given entries

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2,
                                                                                        K k3,
                                                                                        V v3)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

Returns:

A new Map containing the given entries

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2,
                                                                                        K k3,
                                                                                        V v3,
                                                                                        K k4,
                                                                                        V v4)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

Returns:

A new Map containing the given entries

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2,
                                                                                        K k3,
                                                                                        V v3,
                                                                                        K k4,
                                                                                        V v4,
                                                                                        K k5,
                                                                                        V v5)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

Returns:

A new Map containing the given entries

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2,
                                                                                        K k3,
                                                                                        V v3,
                                                                                        K k4,
                                                                                        V v4,
                                                                                        K k5,
                                                                                        V v5,
                                                                                        K k6,
                                                                                        V v6)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

Returns:

A new Map containing the given entries

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2,
                                                                                        K k3,
                                                                                        V v3,
                                                                                        K k4,
                                                                                        V v4,
                                                                                        K k5,
                                                                                        V v5,
                                                                                        K k6,
                                                                                        V v6,
                                                                                        K k7,
                                                                                        V v7)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

k7 - a key for the map

v7 - the value for k7

Returns:

A new Map containing the given entries

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2,
                                                                                        K k3,
                                                                                        V v3,
                                                                                        K k4,
                                                                                        V v4,
                                                                                        K k5,
                                                                                        V v5,
                                                                                        K k6,
                                                                                        V v6,
                                                                                        K k7,
                                                                                        V v7,
                                                                                        K k8,
                                                                                        V v8)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

k7 - a key for the map

v7 - the value for k7

k8 - a key for the map

v8 - the value for k8

Returns:

A new Map containing the given entries

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2,
                                                                                        K k3,
                                                                                        V v3,
                                                                                        K k4,
                                                                                        V v4,
                                                                                        K k5,
                                                                                        V v5,
                                                                                        K k6,
                                                                                        V v6,
                                                                                        K k7,
                                                                                        V v7,
                                                                                        K k8,
                                                                                        V v8,
                                                                                        K k9,
                                                                                        V v9)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

k7 - a key for the map

v7 - the value for k7

k8 - a key for the map

v8 - the value for k8

k9 - a key for the map

v9 - the value for k9

Returns:

A new Map containing the given entries

of

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> of(K k1,
                                                                                        V v1,
                                                                                        K k2,
                                                                                        V v2,
                                                                                        K k3,
                                                                                        V v3,
                                                                                        K k4,
                                                                                        V v4,
                                                                                        K k5,
                                                                                        V v5,
                                                                                        K k6,
                                                                                        V v6,
                                                                                        K k7,
                                                                                        V v7,
                                                                                        K k8,
                                                                                        V v8,
                                                                                        K k9,
                                                                                        V v9,
                                                                                        K k10,
                                                                                        V v10)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

k7 - a key for the map

v7 - the value for k7

k8 - a key for the map

v8 - the value for k8

k9 - a key for the map

v9 - the value for k9

k10 - a key for the map

v10 - the value for k10

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K key,
                                                V value)

Returns a singleton TreeMap, i.e. a TreeMap of one element.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

key - A singleton map key.

value - A singleton map value.

Returns:

A new Map containing the given entry

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2,
                                                K k3,
                                                V v3)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2,
                                                K k3,
                                                V v3,
                                                K k4,
                                                V v4)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2,
                                                K k3,
                                                V v3,
                                                K k4,
                                                V v4,
                                                K k5,
                                                V v5)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2,
                                                K k3,
                                                V v3,
                                                K k4,
                                                V v4,
                                                K k5,
                                                V v5,
                                                K k6,
                                                V v6)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2,
                                                K k3,
                                                V v3,
                                                K k4,
                                                V v4,
                                                K k5,
                                                V v5,
                                                K k6,
                                                V v6,
                                                K k7,
                                                V v7)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

k7 - a key for the map

v7 - the value for k7

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2,
                                                K k3,
                                                V v3,
                                                K k4,
                                                V v4,
                                                K k5,
                                                V v5,
                                                K k6,
                                                V v6,
                                                K k7,
                                                V v7,
                                                K k8,
                                                V v8)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

k7 - a key for the map

v7 - the value for k7

k8 - a key for the map

v8 - the value for k8

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2,
                                                K k3,
                                                V v3,
                                                K k4,
                                                V v4,
                                                K k5,
                                                V v5,
                                                K k6,
                                                V v6,
                                                K k7,
                                                V v7,
                                                K k8,
                                                V v8,
                                                K k9,
                                                V v9)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

k7 - a key for the map

v7 - the value for k7

k8 - a key for the map

v8 - the value for k8

k9 - a key for the map

v9 - the value for k9

Returns:

A new Map containing the given entries

of

public static <K,V> TreeMap<K,V> of(java.util.Comparator<? super K> keyComparator,
                                                K k1,
                                                V v1,
                                                K k2,
                                                V v2,
                                                K k3,
                                                V v3,
                                                K k4,
                                                V v4,
                                                K k5,
                                                V v5,
                                                K k6,
                                                V v6,
                                                K k7,
                                                V v7,
                                                K k8,
                                                V v8,
                                                K k9,
                                                V v9,
                                                K k10,
                                                V v10)

Creates a TreeMap of the given list of key-value pairs.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

k1 - a key for the map

v1 - the value for k1

k2 - a key for the map

v2 - the value for k2

k3 - a key for the map

v3 - the value for k3

k4 - a key for the map

v4 - the value for k4

k5 - a key for the map

v5 - the value for k5

k6 - a key for the map

v6 - the value for k6

k7 - a key for the map

v7 - the value for k7

k8 - a key for the map

v8 - the value for k8

k9 - a key for the map

v9 - the value for k9

k10 - a key for the map

v10 - the value for k10

Returns:

A new Map containing the given entries

tabulate

public static <K,V> TreeMap<K,V> tabulate(java.util.Comparator<? super K> keyComparator,
                                                      int n,
                                                      @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V>> f)

Returns a TreeMap containing n values of a given Function f over a range of integer values from 0 to n - 1.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key

n - The number of elements in the TreeMap

f - The Function computing element values

Returns:

A TreeMap consisting of elements f(0),f(1), ..., f(n - 1)

Throws:

java.lang.NullPointerException - if keyComparator or f are null

tabulate

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> tabulate(int n,
                                                                                              @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V>> f)

Returns a TreeMap containing n values of a given Function f over a range of integer values from 0 to n - 1. The underlying key comparator is the natural comparator of K.

Type Parameters:

K - The key type

V - The value type

Parameters:

n - The number of elements in the TreeMap

f - The Function computing element values

Returns:

A TreeMap consisting of elements f(0),f(1), ..., f(n - 1)

Throws:

java.lang.NullPointerException - if f is null

fill

public static <K,V> TreeMap<K,V> fill(@NonNull java.util.Comparator<? super K> keyComparator,
                                                  int n,
                                                  @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)

Returns a TreeMap containing tuples returned by n calls to a given Supplier s.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key

n - The number of elements in the TreeMap

s - The Supplier computing element values

Returns:

A TreeMap of size n, where each element contains the result supplied by s.

Throws:

java.lang.NullPointerException - if keyComparator or s are null

fill

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> fill(int n,
                                                                                          @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)

Returns a TreeMap containing tuples returned by n calls to a given Supplier s. The underlying key comparator is the natural comparator of K.

Type Parameters:

K - The key type

V - The value type

Parameters:

n - The number of elements in the TreeMap

s - The Supplier computing element values

Returns:

A TreeMap of size n, where each element contains the result supplied by s.

Throws:

java.lang.NullPointerException - if s is null

ofEntries

@SafeVarargs
public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> ofEntries(@NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)

Creates a TreeMap of the given entries using the natural key comparator.

Type Parameters:

K - The key type

V - The value type

Parameters:

entries - Map entries

Returns:

A new TreeMap containing the given entries.

ofEntries

@SafeVarargs
public static <K,V> TreeMap<K,V> ofEntries(@NonNull java.util.Comparator<? super K> keyComparator,
                                                       @NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)

Creates a TreeMap of the given entries using the given key comparator.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

entries - Map entries

Returns:

A new TreeMap containing the given entries.

ofEntries

@SafeVarargs
public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> ofEntries(@NonNull java.util.Map.Entry<? extends K,? extends V> @NonNull ... entries)

Creates a TreeMap of the given entries using the natural key comparator.

Type Parameters:

K - The key type

V - The value type

Parameters:

entries - Map entries

Returns:

A new TreeMap containing the given entries.

ofEntries

@SafeVarargs
public static <K,V> TreeMap<K,V> ofEntries(@NonNull java.util.Comparator<? super K> keyComparator,
                                                       @NonNull java.util.Map.Entry<? extends K,? extends V> @NonNull ... entries)

Creates a TreeMap of the given entries using the given key comparator.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

entries - Map entries

Returns:

A new TreeMap containing the given entries.

ofEntries

public static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V> ofEntries(@NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)

Creates a TreeMap of the given entries.

Type Parameters:

K - The key type

V - The value type

Parameters:

entries - Map entries

Returns:

A new TreeMap containing the given entries.

ofEntries

public static <K,V> TreeMap<K,V> ofEntries(@NonNull java.util.Comparator<? super K> keyComparator,
                                                       @NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)

Creates a TreeMap of the given entries.

Type Parameters:

K - The key type

V - The value type

Parameters:

keyComparator - The comparator used to sort the entries by their key.

entries - Map entries

Returns:

A new TreeMap containing the given entries.

bimap

public <K2,V2> TreeMap<K2,V2> bimap(@NonNull java.util.function.Function<? super K,? extends K2> keyMapper,
                                                @NonNull java.util.function.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>

Specified by:

bimap in interface SortedMap<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

bimap

public <K2,V2> TreeMap<K2,V2> bimap(@NonNull java.util.Comparator<? super K2> keyComparator,
                                                @NonNull java.util.function.Function<? super K,? extends K2> keyMapper,
                                                java.util.function.Function<? super V,? extends V2> valueMapper)

Description copied from interface: SortedMap

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

Specified by:

bimap in interface SortedMap<K,V>

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

computeIfAbsent

public Tuple2<V,TreeMap<K,V>> computeIfAbsent(K key,
                                                          @NonNull java.util.function.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>

Specified by:

computeIfAbsent in interface SortedMap<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

public Tuple2<Option<V>,TreeMap<K,V>> computeIfPresent(K key,
                                                                   @NonNull java.util.function.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>

Specified by:

computeIfPresent in interface SortedMap<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

containsKey

public boolean containsKey(K key)

Description copied from interface: Map

Returns true if this map contains a mapping for the specified key.

Specified by:

containsKey in interface Map<K,V>

Parameters:

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

Returns:

true if this map contains a mapping for the specified key

distinct

public TreeMap<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 SortedMap<K,V>

Specified by:

distinct in interface Traversable<K>

Returns:

a new Traversable without duplicate elements

distinctBy

public TreeMap<K,V> distinctBy(@NonNull java.util.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 SortedMap<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

public <U> TreeMap<K,V> distinctBy(@NonNull java.util.function.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 SortedMap<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

public TreeMap<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 SortedMap<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

public TreeMap<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 SortedMap<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

public TreeMap<K,V> dropUntil(@NonNull java.util.function.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 SortedMap<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

public TreeMap<K,V> dropWhile(@NonNull java.util.function.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 SortedMap<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

public TreeMap<K,V> filter(@NonNull java.util.function.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>

Specified by:

filter in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test elements

Returns:

a new Map

reject

public TreeMap<K,V> reject(@NonNull java.util.function.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>

Specified by:

reject in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test elements

Returns:

a new Map

filter

public TreeMap<K,V> filter(@NonNull java.util.function.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 SortedMap<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

public TreeMap<K,V> reject(@NonNull java.util.function.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 SortedMap<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

filterKeys

public TreeMap<K,V> filterKeys(@NonNull java.util.function.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>

Specified by:

filterKeys in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test keys of elements

Returns:

a new Map

rejectKeys

public TreeMap<K,V> rejectKeys(@NonNull java.util.function.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>

Specified by:

rejectKeys in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test keys of elements

Returns:

a new Map

filterValues

public TreeMap<K,V> filterValues(@NonNull java.util.function.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>

Specified by:

filterValues in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test values of elements

Returns:

a new Map

rejectValues

public TreeMap<K,V> rejectValues(@NonNull java.util.function.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>

Specified by:

rejectValues in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test values of elements

Returns:

a new Map

flatMap

public <K2,V2> TreeMap<K2,V2> flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.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>

Specified by:

flatMap in interface SortedMap<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.

flatMap

public <K2,V2> TreeMap<K2,V2> flatMap(@NonNull java.util.Comparator<? super K2> keyComparator,
                                                  @NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)

Description copied from interface: SortedMap

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

Specified by:

flatMap in interface SortedMap<K,V>

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

get

public Option<V> get(K key)

Description copied from interface: Map

Returns the Some of value to which the specified key is mapped, or None if this map contains no mapping for the key.

Specified by:

get in interface Map<K,V>

Parameters:

key - the key whose associated value is to be returned

Returns:

the Some of value to which the specified key is mapped, or None if this map contains no mapping for the key

getOrElse

public V getOrElse(K key,
                   V defaultValue)

Description copied from interface: Map

Returns the value associated with a key, or a default value if the key is not contained in the map.

Specified by:

getOrElse in interface Map<K,V>

Parameters:

key - the key

defaultValue - a default value

Returns:

the value associated with key if it exists, otherwise the default value.

groupBy

public <C> Map<C,TreeMap<K,V>> groupBy(@NonNull java.util.function.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 SortedMap<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

public Iterator<TreeMap<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 SortedMap<K,V>

Specified by:

grouped in interface Traversable<K>

Parameters:

size - the block size; must be positive

Returns:

an Iterator over blocks of elements

head

public Tuple2<K,V> head()

Description copied from interface: Traversable

Returns the first element of this non-empty Traversable.

Specified by:

head in interface Traversable<K>

Returns:

the first element

last

public Tuple2<K,V> last()

Description copied from interface: Traversable

Returns the last element of this Traversable.

Specified by:

last in interface SortedMap<K,V>

Specified by:

last in interface Traversable<K>

Returns:

the last element

init

public TreeMap<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 SortedMap<K,V>

Specified by:

init in interface Traversable<K>

Returns:

a new instance containing all elements except the last

initOption

public Option<TreeMap<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 SortedMap<K,V>

Specified by:

initOption in interface Traversable<K>

Returns:

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

isAsync

public boolean isAsync()

An TreeMap's value is computed synchronously.

Specified by:

isAsync in interface Value<K>

Returns:

false

isEmpty

public boolean isEmpty()

Description copied from interface: Traversable

Checks if this Traversable contains no elements.

Specified by:

isEmpty in interface Traversable<K>

Specified by:

isEmpty in interface Value<K>

Returns:

true if empty, false otherwise

isLazy

public boolean isLazy()

An TreeMap's value is computed eagerly.

Specified by:

isLazy in interface Value<K>

Returns:

false

iterator

public @NonNull Iterator<Tuple2<K,V>> iterator()

Description copied from interface: Traversable

Returns an iterator over the elements of this Traversable, implemented via Traversable.head() and Traversable.tail(). Subclasses may override for a more efficient implementation.

Specified by:

iterator in interface java.lang.Iterable<K>

Specified by:

iterator in interface Map<K,V>

Specified by:

iterator in interface Traversable<K>

Specified by:

iterator in interface Value<K>

Returns:

a new Iterator over the elements of this Traversable

keySet

public SortedSet<K> keySet()

Description copied from interface: Map

Returns the keys contained in this map.

Specified by:

keySet in interface Map<K,V>

Specified by:

keySet in interface SortedMap<K,V>

Returns:

Set of the keys contained in this map.

map

public <K2,V2> TreeMap<K2,V2> map(@NonNull java.util.function.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>

Specified by:

map in interface SortedMap<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

map

public <K2,V2> TreeMap<K2,V2> map(@NonNull java.util.Comparator<? super K2> keyComparator,
                                              @NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)

Description copied from interface: SortedMap

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

Specified by:

map in interface SortedMap<K,V>

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

mapKeys

public <K2> TreeMap<K2,V> mapKeys(@NonNull java.util.function.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>

Specified by:

mapKeys in interface SortedMap<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

public <K2> TreeMap<K2,V> mapKeys(@NonNull java.util.function.Function<? super K,? extends K2> keyMapper,
                                        @NonNull java.util.function.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>

Specified by:

mapKeys in interface SortedMap<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

public <W> TreeMap<K,W> mapValues(@NonNull java.util.function.Function<? super V,? extends W> 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>

Specified by:

mapValues in interface SortedMap<K,V>

Type Parameters:

W - the new value type

Parameters:

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

Returns:

a new Map

merge

public TreeMap<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>

Specified by:

merge in interface SortedMap<K,V>

Parameters:

that - the other map

Returns:

A merged map

merge

public <U extends V> TreeMap<K,V> merge(@NonNull Map<? extends K,U> that,
                                              @NonNull java.util.function.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>

Specified by:

merge in interface SortedMap<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

public TreeMap<K,V> orElse(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> other)

Returns this TreeMap if it is nonempty, otherwise TreeMap created from iterable, using existing comparator.

Specified by:

orElse in interface Map<K,V>

Specified by:

orElse in interface SortedMap<K,V>

Specified by:

orElse in interface Traversable<K>

Parameters:

other - An alternative Traversable

Returns:

this TreeMap if it is nonempty, otherwise TreeMap created from iterable, using existing comparator.

orElse

public TreeMap<K,V> orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)

Returns this TreeMap if it is nonempty, otherwise TreeMap created from result of evaluating supplier, using existing comparator.

Specified by:

orElse in interface Map<K,V>

Specified by:

orElse in interface SortedMap<K,V>

Specified by:

orElse in interface Traversable<K>

Parameters:

supplier - An alternative Traversable

Returns:

this TreeMap if it is nonempty, otherwise TreeMap created from result of evaluating supplier, using existing comparator.

partition

public Tuple2<TreeMap<K,V>,TreeMap<K,V>> partition(@NonNull java.util.function.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 SortedMap<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

public TreeMap<K,V> peek(@NonNull java.util.function.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 SortedMap<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

public <U extends V> TreeMap<K,V> put(K key,
                                            U value,
                                            @NonNull java.util.function.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>

Specified by:

put in interface SortedMap<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

public TreeMap<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>

Specified by:

put in interface SortedMap<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

public TreeMap<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>

Specified by:

put in interface SortedMap<K,V>

Parameters:

entry - A Tuple2 containing the key and value

Returns:

A new Map containing these elements and that entry.

put

public <U extends V> TreeMap<K,V> put(@NonNull Tuple2<? extends K,U> entry,
                                            @NonNull java.util.function.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>

Specified by:

put in interface SortedMap<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

public TreeMap<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>

Specified by:

remove in interface SortedMap<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

@Deprecated
public TreeMap<K,V> removeAll(@NonNull java.util.function.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>

Specified by:

removeAll in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test elements

Returns:

a new Map

removeAll

public TreeMap<K,V> removeAll(@NonNull java.lang.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>

Specified by:

removeAll in interface SortedMap<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.

removeKeys

@Deprecated
public TreeMap<K,V> removeKeys(@NonNull java.util.function.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>

Specified by:

removeKeys in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test keys of elements

Returns:

a new Map

removeValues

@Deprecated
public TreeMap<K,V> removeValues(@NonNull java.util.function.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>

Specified by:

removeValues in interface SortedMap<K,V>

Parameters:

predicate - the predicate used to test values of elements

Returns:

a new Map

replace

public TreeMap<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 SortedMap<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

replaceAll

public TreeMap<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 SortedMap<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

replaceValue

public TreeMap<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>

Specified by:

replaceValue in interface SortedMap<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.

replace

public TreeMap<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>

Specified by:

replace in interface SortedMap<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.

replaceAll

public TreeMap<K,V> replaceAll(@NonNull java.util.function.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>

Specified by:

replaceAll in interface SortedMap<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.

retainAll

public TreeMap<K,V> retainAll(@NonNull java.lang.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 SortedMap<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

public TreeMap<K,V> scan(@NonNull Tuple2<K,V> zero,
                               @NonNull java.util.function.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 SortedMap<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

size

public int size()

Description copied from interface: Traversable

Returns the number of elements in this Traversable.

Alias for Traversable.length().

Specified by:

size in interface Map<K,V>

Specified by:

size in interface Traversable<K>

Returns:

the number of elements

slideBy

public Iterator<TreeMap<K,V>> slideBy(@NonNull java.util.function.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 SortedMap<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

public Iterator<TreeMap<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 SortedMap<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

public Iterator<TreeMap<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 SortedMap<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

public Tuple2<TreeMap<K,V>,TreeMap<K,V>> span(@NonNull java.util.function.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 SortedMap<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

public TreeMap<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 SortedMap<K,V>

Specified by:

tail in interface Traversable<K>

Returns:

a new Traversable containing all elements except the first

tailOption

public Option<TreeMap<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 SortedMap<K,V>

Specified by:

tailOption in interface Traversable<K>

Returns:

Some(traversable) if non-empty, otherwise None

take

public TreeMap<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 SortedMap<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

public TreeMap<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 SortedMap<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

public TreeMap<K,V> takeUntil(@NonNull java.util.function.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 SortedMap<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

public TreeMap<K,V> takeWhile(@NonNull java.util.function.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 SortedMap<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

public java.util.TreeMap<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>

Specified by:

toJavaMap in interface SortedMap<K,V>

Returns:

a new java.util.Map instance

values

public Seq<V> values()

Description copied from interface: Map

Returns a new Seq that contains the values of this Map.

 // = Seq("a", "b", "c")
 HashMap.of(1, "a", 2, "b", 3, "c").values()
 

Specified by:

values in interface Map<K,V>

Returns:

a new Seq

equals

public boolean equals(java.lang.Object o)

Description copied from interface: Traversable

Determines whether this collection is equal to the given object.

In Vavr, there are four basic collection types:

• Seq – sequential elements
• Set – distinct elements
• Map – key-value pairs
• Multimap – keys mapped to multiple values

Two collections are considered equal if and only if:

• They are of the same collection type (Seq, Set, Map, Multimap)
• They contain the same elements
• For Seq, the element order is the same

For Map and Multimap, two entries (key1, value1) and (key2, value2) are equal if both their keys and values are equal.

Additional notes:

• No collection equals null (e.g., Queue(1) != null)
• Null elements are allowed and treated as expected (e.g., List(null, 1) == Stream(null, 1), HashMap((null,1)) == LinkedHashMap((null,1)))
• Element order matters only for Seq
• Other collection classes are equal if their types and elements (in iteration order) are equal
• Iterators are compared by reference only

Specified by:

equals in interface Traversable<K>

Specified by:

equals in interface Value<K>

Overrides:

equals in class java.lang.Object

Parameters:

o - the object to compare with, may be null

Returns:

true if the collections are equal according to the rules above, false otherwise

hashCode

public int hashCode()

Description copied from interface: Traversable

Returns the hash code of this collection.

Vavr distinguishes between collections with predictable iteration order (like Seq) and collections with arbitrary iteration order (like Set, Map, and Multimap). In all cases, the hash of an empty collection is defined as 1.

For collections with predictable iteration order, the hash is computed as:

 int hash = 1;
 for (T t : this) {
     hash = hash * 31 + Objects.hashCode(t);
 }
 

For collections with arbitrary iteration order, the hash is computed to be independent of element order:

 int hash = 1;
 for (T t : this) {
     hash += Objects.hashCode(t);
 }
 

Note that these algorithms may change in future Vavr versions. Hash codes are generally not cached, unlike size/length, because caching would increase memory usage due to persistent tree-based structures. Computing the hash code is linear in time, O(n). For frequently re-used collections (e.g., as HashMap keys), caching can be done externally using a wrapper, for example:

{@code
 public final class Hashed {
     private final K key;
     private final Lazy hashCode;

     public Hashed(K key) {
         this.key = key;
         this.hashCode = Lazy.of(() -> Objects.hashCode(key));
     }

     public K key() { return key; }

Specified by:

hashCode in interface Traversable<K>

Specified by:

hashCode in interface Value<K>

Overrides:

hashCode in class java.lang.Object

Returns:

the hash code of this collection

stringPrefix

public java.lang.String stringPrefix()

Description copied from interface: Value

Returns the name of this Value type, which is used by toString().

Specified by:

stringPrefix in interface Value<K>

Returns:

This type name.

toString

public java.lang.String toString()

Description copied from interface: Value

Clarifies that values have a proper toString() method implemented.

See Object.toString().

Specified by:

toString in interface Value<K>

Overrides:

toString in class java.lang.Object

Returns:

A String representation of this object

bimap

private static <K,K2,V,V2> TreeMap<K2,V2> bimap(@NonNull TreeMap<K,V> map,
                                                                        @NonNull TreeMap.EntryComparator<K2,V2> entryComparator,
                                                                        java.util.function.Function<? super K,? extends K2> keyMapper,
                                                                        java.util.function.Function<? super V,? extends V2> valueMapper)

flatMap

private static <K,V,K2,V2> TreeMap<K2,V2> flatMap(@NonNull TreeMap<K,V> map,
                                                                          @NonNull TreeMap.EntryComparator<K2,V2> entryComparator,
                                                                          java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)

map

private static <K,K2,V,V2> TreeMap<K2,V2> map(@NonNull TreeMap<K,V> map,
                                                                      @NonNull TreeMap.EntryComparator<K2,V2> entryComparator,
                                                                      java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)

createCollector

private static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>> createCollector(@NonNull TreeMap.EntryComparator<K,V> entryComparator)

createCollector

private static <K,V,T> java.util.stream.Collector<T,java.util.ArrayList<T>,TreeMap<K,V>> createCollector(@NonNull TreeMap.EntryComparator<K,V> entryComparator,
                                                                                                                                       @NonNull java.util.function.Function<? super T,? extends K> keyMapper,
                                                                                                                                       @NonNull java.util.function.Function<? super T,? extends V> valueMapper)

createTreeMap

private static <K,V> TreeMap<K,V> createTreeMap(@NonNull TreeMap.EntryComparator<K,V> entryComparator,
                                                            @NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)

createTreeMap

private static <K,K2,V,V2> TreeMap<K2,V2> createTreeMap(@NonNull TreeMap.EntryComparator<K2,V2> entryComparator,
                                                                                @NonNull java.lang.Iterable<Tuple2<K,V>> entries,
                                                                                java.util.function.Function<Tuple2<K,V>,Tuple2<K2,V2>> entryMapper)

createFromMap

private static <K,V> TreeMap<K,V> createFromMap(@NonNull TreeMap.EntryComparator<K,V> entryComparator,
                                                            @NonNull java.util.Map<? extends K,? extends V> map)

createFromTuple

private static <K,V> TreeMap<K,V> createFromTuple(@NonNull TreeMap.EntryComparator<K,V> entryComparator,
                                                              @NonNull Tuple2<? extends K,? extends V> entry)

createFromTuples

private static <K,V> TreeMap<K,V> createFromTuples(@NonNull TreeMap.EntryComparator<K,V> entryComparator,
                                                               @NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)

createFromMapEntries

@SafeVarargs
private static <K,V> TreeMap<K,V> createFromMapEntries(@NonNull TreeMap.EntryComparator<K,V> entryComparator,
                                                                   @NonNull java.util.Map.Entry<? extends K,? extends V> @NonNull ... entries)

createFromPairs

private static <K,V> TreeMap<K,V> createFromPairs(@NonNull TreeMap.EntryComparator<K,V> entryComparator,
                                                              @NonNull java.lang.Object @NonNull ... pairs)

createFromEntries

private TreeMap<K,V> createFromEntries(@NonNull java.lang.Iterable<Tuple2<K,V>> tuples)

emptyInstance

private TreeMap<K,V> emptyInstance()

comparator

public java.util.Comparator<K> comparator()

Description copied from interface: Ordered

Returns the comparator that governs the ordering of elements in this collection. The returned comparator must be consistent with the collection's iteration order.

Specified by:

comparator in interface Ordered<K>

Returns:

the comparator defining the element order