Vavr 0.10.6 · io.vavr.collection.Map · APIdia, the JavaDoc alternative

Modifier and Type	Field and Description
public static final long	serialVersionUID Hides io.vavr.PartialFunction.serialVersionUID.

Method Summary

Modifier and Type	Method and Description
public default V	apply(K the argument key) Implements io.vavr.PartialFunction.apply. Deprecated Applies this function to the given argument and returns the result.
public default PartialFunction<K, V>	Returns: a new `PartialFunction` asPartialFunction() Turns this `Map` into a `PartialFunction` which is defined at a specific index, if this `Map` contains the given key.
public < key's component type of the map result K2, value's component type of the map result V2> Map<K2, V2>	Returns: a new `Map` bimap(Function<? super K, ? extends K2> a `Function` that maps the keys of type `K` to keys of type `K2` keyMapper, Function<? super V, ? extends V2> a `Function` that the values of type `V` to values of type `V2` valueMapper) Maps this `Map` to a new `Map` with different component type by applying a function to its elements.
public default <R> Seq<R>	collect(PartialFunction<? super Tuple2<K, V>, ? extends R> A function that is not necessarily defined of all elements of this traversable. partialFunction) Implements io.vavr.collection.Traversable.collect. Collects all elements that are in the domain of the given `partialFunction` by mapping the elements to type `R`.
public Tuple2<V, ? extends Map<K, V>>	Returns: the `Tuple2` of current or modified map and existing or computed value associated with the specified key computeIfAbsent(K key whose presence in this map is to be tested key, Function<? super K, ? extends V> mapping function 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.
public Tuple2<Option<V>, ? extends Map<K, V>>	Returns: the `Tuple2` of current or modified map and the `Some` of the value associated with the specified key, or `None` if none computeIfPresent(K key whose presence in this map is to be tested key, BiFunction<? super K, ? super V, ? extends V> remapping function remappingFunction) If the value for the specified key is present, attempts to compute a new mapping given the key and its current mapped value.
public default boolean	contains(Tuple2<K, V> An Object of type A, may be null. element) Overrides default io.vavr.Value.contains. Shortcut for `exists(e -> Objects.equals(e, element))`, tests if the given `element` is contained.
public boolean	Returns: `true` if this map contains a mapping for the specified key containsKey(K key whose presence in this map is to be tested key) Returns `true` if this map contains a mapping for the specified key.
public default boolean	Returns: `true` if this map maps one or more keys to the specified value containsValue(V value whose presence in this map is to be tested value) Returns `true` if this map maps one or more keys to the specified value.
public Map<K, V>	distinct() Redeclares io.vavr.collection.Traversable.distinct. Returns a new version of this which contains no duplicates.
public Map<K, V>	distinctBy(Comparator<? super Tuple2<K, V>> A comparator comparator) Redeclares io.vavr.collection.Traversable.distinctBy. Returns a new version of this which contains no duplicates.
public <U> Map<K, V>	distinctBy(Function<? super Tuple2<K, V>, ? extends U> A key extractor keyExtractor) Redeclares io.vavr.collection.Traversable.distinctBy. Returns a new version of this which contains no duplicates.
public Map<K, V>	drop(int The number of elements to drop. n) Redeclares io.vavr.collection.Traversable.drop. Drops the first n elements of this or all elements, if this length < n.
public Map<K, V>	dropRight(int The number of elements to drop. n) Redeclares io.vavr.collection.Traversable.dropRight. Drops the last n elements of this or all elements, if this length < n.
public Map<K, V>	dropUntil(Predicate<? super Tuple2<K, V>> A condition tested subsequently for this elements. predicate) Redeclares io.vavr.collection.Traversable.dropUntil. Drops elements until the predicate holds for the current element.
public Map<K, V>	dropWhile(Predicate<? super Tuple2<K, V>> A condition tested subsequently for this elements. predicate) Redeclares io.vavr.collection.Traversable.dropWhile. Drops elements while the predicate holds for the current element.
public static < Key type K, Value type V> Tuple2<K, V>	Returns: a key/value pair entry(K the entry's key key, V the entry's value value) Convenience factory method to create a key/value pair.
public Map<K, V>	Returns: a new Map filter(BiPredicate<? super K, ? super V> the predicate used to test elements predicate) Returns a new Map consisting of all elements which satisfy the given predicate.
public Map<K, V>	filter(Predicate<? super Tuple2<K, V>> A predicate predicate) Redeclares io.vavr.collection.Traversable.filter. Returns a new traversable consisting of all elements which satisfy the given predicate.
public Map<K, V>	Returns: a new Map filterKeys(Predicate<? super K> the predicate used to test keys of elements predicate) Returns a new Map consisting of all elements with keys which satisfy the given predicate.
public Map<K, V>	Returns: a new Map filterValues(Predicate<? super V> the predicate used to test values of elements predicate) Returns a new Map consisting of all elements with values which satisfy the given predicate.
public < key's component type of the mapped `Map` K2, value's component type of the mapped `Map` V2> Map<K2, V2>	Returns: A new `Map`. flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2, V2>>> A mapper mapper) FlatMaps this `Map` to a new `Map` with different component type.
public default < Component type U> Seq<U>	Returns: A sequence of flat-mapped values. flatMap(Function<? super Tuple2<K, V>, ? extends Iterable<? extends U>> A mapper mapper) Implements io.vavr.collection.Traversable.flatMap. Flat-maps this entries to a sequence of values.
public default <U> U	foldRight(U A zero element to start with. zero, BiFunction<? super Tuple2<K, V>, ? super U, ? extends U> A function which combines elements. f) Implements io.vavr.collection.Traversable.foldRight. Folds this elements from the right, starting with `zero` and successively calling `combine`.
public default void	forEach(BiConsumer<K, V> A `BiConsumer` action) Performs an action on key, value pair.
public Option<V>	Returns: the `Some` of value to which the specified key is mapped, or `None` if this map contains no mapping for the key get(K the key whose associated value is to be returned key) Returns the `Some` of value to which the specified key is mapped, or `None` if this map contains no mapping for the key.
public V	Returns: the value associated with key if it exists, otherwise the default value. getOrElse(K the key key, V a default value defaultValue) Returns the value associated with a key, or a default value if the key is not contained in the map.
public <C> Map<C, ? extends Map<K, V>>	groupBy(Function<? super Tuple2<K, V>, ? extends C> A function which classifies elements into classes classifier) Redeclares io.vavr.collection.Traversable.groupBy. Groups this elements by classifying the elements.
public Iterator<? extends Map<K, V>>	grouped(int a positive block size size) Redeclares io.vavr.collection.Traversable.grouped. Groups this `Traversable` into fixed size blocks.
public default boolean	hasDefiniteSize() Implements io.vavr.collection.Traversable.hasDefiniteSize. Checks if this Traversable is known to have a finite size.
public Map<K, V>	init() Redeclares io.vavr.collection.Traversable.init. Dual of tail(), returning all elements except the last.
public Option<? extends Map<K, V>>	initOption() Redeclares as abstract: io.vavr.collection.Traversable.initOption. Dual of tailOption(), returning all elements except the last as `Option`.
public default boolean	isDefinedAt(K a potential function argument key) Implements io.vavr.PartialFunction.isDefinedAt. Deprecated Tests if a value is contained in the function's domain.
public default boolean	isDistinct() Overrides default io.vavr.collection.Traversable.isDistinct. Checks if this Traversable may consist of distinct elements only.
public default boolean	isTraversableAgain() Implements io.vavr.collection.Traversable.isTraversableAgain. Checks if this Traversable can be repeatedly traversed.
public Iterator<Tuple2<K, V>>	iterator() Redeclares as abstract: io.vavr.collection.Traversable.iterator. An iterator by means of head() and tail().
public default < The type of the resulting elements U> Iterator<U>	Returns: An iterator through the mapped elements. iterator(BiFunction<K, V, ? extends U> A function that maps (key, value) pairs to elements of type U mapper) Iterates this Map sequentially, mapping the (key, value) pairs to elements.
public Set<K>	Returns: `Set` of the keys contained in this map. keySet() Returns the keys contained in this map.
public default Iterator<K>	Returns: `Iterator` of the keys contained in this map. keysIterator() Returns the keys contained in this map as an iterator.
public default int	length() Implements io.vavr.collection.Traversable.length. Computes the number of elements of this Traversable.
public default Function1<K, Option<V>>	Returns: a function that takes a key k and returns its value in a Some if found, otherwise a None. lift() Overrides default io.vavr.PartialFunction.lift. Turns this map into a plain function returning an Option result.
public default < Component type U> Seq<U>	Returns: A sequence of mapped values. map(Function<? super Tuple2<K, V>, ? extends U> A mapper mapper) Implements io.vavr.collection.Traversable.map. Maps the `Map` entries to a sequence of values.
public < key's component type of the map result K2, value's component type of the map result V2> Map<K2, V2>	Returns: a new `Map` map(BiFunction<? super K, ? super V, Tuple2<K2, V2>> a `Function` that maps entries of type `(K, V)` to entries of type `(K2, V2)` mapper) Maps the entries of this `Map` to form a new `Map`.
public < the new key type K2> Map<K2, V>	Returns: a new `Map` mapKeys(Function<? super K, ? extends K2> a `Function` that maps keys of type `V` to keys of type `V2` keyMapper) Maps the keys of this `Map` while preserving the corresponding values.
public < the new key type K2> Map<K2, V>	Returns: a new `Map` mapKeys(Function<? super K, ? extends K2> a `Function` that maps keys of type `V` to keys of type `V2` keyMapper, BiFunction<? super V, ? super V, ? extends V> a `BiFunction` that merges values valueMerge) Maps the keys of this `Map` while preserving the corresponding values and applying a value merge function on collisions.
public < the new value type V2> Map<K, V2>	Returns: a new `Map` mapValues(Function<? super V, ? extends V2> a `Function` that maps values of type `V` to values of type `V2` valueMapper) Maps the values of this `Map` while preserving the corresponding keys.
public Map<K, V>	Returns: A merged map merge(Map<? extends K, ? extends V> the other map that) Creates a new map which by merging the entries of `this` map and `that` map.
public < value type of that Map U extends V> Map<K, V>	Returns: A merged map merge(Map<? extends K, U> the other map that, BiFunction<? super V, ? super U, ? extends V> the collision resolution function collisionResolution) Creates a new map which by merging the entries of `this` map and `that` map.
public static < Key type K, Value type V> Map<K, V>	Returns: the given `map` instance as narrowed type `Map<K, V>`. narrow(Map<? extends K, ? extends V> A `Map`. map) Narrows a widened `Map<?`
public Map<K, V>	orElse(Iterable<? extends Tuple2<K, V>> An alternative `Traversable` other) Redeclares io.vavr.collection.Traversable.orElse. Returns this `Traversable` if it is nonempty, otherwise return the alternative.
public Map<K, V>	orElse(Supplier<? extends Iterable<? extends Tuple2<K, V>>> An alternative `Traversable` supplier supplier) Redeclares io.vavr.collection.Traversable.orElse. Returns this `Traversable` if it is nonempty, otherwise return the result of evaluating supplier.
public Tuple2<? extends Map<K, V>, ? extends Map<K, V>>	partition(Predicate<? super Tuple2<K, V>> A predicate which classifies an element if it is in the first or the second traversable. predicate) Redeclares io.vavr.collection.Traversable.partition. Creates a partition of this `Traversable` by splitting this elements in two in distinct traversables according to a predicate.
public Map<K, V>	peek(Consumer<? super Tuple2<K, V>> The action that will be performed on the element(s). action) Redeclares io.vavr.collection.Traversable.peek. Performs the given `action` on the first element if this is an eager implementation.
public Map<K, V>	Returns: A new Map containing these elements and that entry. put(K key with which the specified value is to be associated key, V value to be associated with the specified key value) Associates the specified value with the specified key in this map.
public Map<K, V>	Returns: A new Map containing these elements and that entry. put(Tuple2<? extends K, ? extends V> A Tuple2 containing the key and value entry) Convenience method for `put(entry._1, entry._2)`.
public < the value type U extends V> Map<K, V>	Returns: A new Map containing these elements and that entry. put(K key with which the specified value is to be associated key, U value to be associated with the specified key value, BiFunction<? super V, ? super U, ? extends V> function taking the old and new values and merging them. merge) Associates the specified value with the specified key in this map.
public < the value type U extends V> Map<K, V>	Returns: A new Map containing these elements and that entry. put(Tuple2<? extends K, U> A Tuple2 containing the key and value entry, BiFunction<? super V, ? super U, ? extends V> function taking the old and new values and merging them. merge) Convenience method for `put(entry._1, entry._2, merge)`.
public Map<K, V>	Returns: a new Map reject(BiPredicate<? super K, ? super V> the predicate used to test elements predicate) Returns a new Map consisting of all elements which do not satisfy the given predicate.
public Map<K, V>	reject(Predicate<? super Tuple2<K, V>> A predicate predicate) Redeclares as abstract: io.vavr.collection.Traversable.reject. Returns a new traversable consisting of all elements which do not satisfy the given predicate.
public Map<K, V>	Returns: a new Map rejectKeys(Predicate<? super K> the predicate used to test keys of elements predicate) Returns a new Map consisting of all elements with keys which do not satisfy the given predicate.
public Map<K, V>	Returns: a new Map rejectValues(Predicate<? super V> the predicate used to test values of elements predicate) Returns a new Map consisting of all elements with values which do not satisfy the given predicate.
public Map<K, V>	Returns: A new Map containing these elements without the entry specified by that key. remove(K key whose mapping is to be removed from the map key) Removes the mapping for a key from this map if it is present.
public Map<K, V>	Returns: a new Map removeAll(BiPredicate<? super K, ? super V> the predicate used to test elements predicate) Deprecated Please use `reject(BiPredicate)` Returns a new Map consisting of all elements which do not satisfy the given predicate.
public Map<K, V>	Returns: A new Map containing these elements without the entries specified by that keys. removeAll(Iterable<? extends K> keys are to be removed from the map keys) Removes the mapping for a key from this map if it is present.
public Map<K, V>	Returns: a new Map removeKeys(Predicate<? super K> the predicate used to test keys of elements predicate) Deprecated Please use `rejectKeys(Predicate)` Returns a new Map consisting of all elements with keys which do not satisfy the given predicate.
public Map<K, V>	Returns: a new Map removeValues(Predicate<? super V> the predicate used to test values of elements predicate) Deprecated Please use `rejectValues(Predicate)` Returns a new Map consisting of all elements with values which do not satisfy the given predicate.
public Map<K, V>	replace(Tuple2<K, V> An element to be substituted. currentElement, Tuple2<K, V> A replacement for currentElement. newElement) Redeclares io.vavr.collection.Traversable.replace. Replaces the first occurrence (if exists) of the given currentElement with newElement.
public Map<K, V>	Returns: a new map containing key mapped to newValue if key was contained before and oldValue matched. The old map otherwise. replace(K the key of the element to be substituted. key, V the expected current value that the key is currently mapped to oldValue, V the new value to be associated with the key newValue) Replaces the entry for the specified key only if currently mapped to the specified value.
public Map<K, V>	Returns: a new map with the same keySet but transformed values. replaceAll(BiFunction<? super K, ? super V, ? extends V> function transforming key and current value to a new value 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.
public Map<K, V>	replaceAll(Tuple2<K, V> An element to be substituted. currentElement, Tuple2<K, V> A replacement for currentElement. newElement) Redeclares io.vavr.collection.Traversable.replaceAll. Replaces all occurrences of the given currentElement with newElement.
public Map<K, V>	Returns: a new map containing key mapped to value if key was contained before. The old map otherwise. replaceValue(K the key of the element to be substituted. key, V the new value to be associated with the key value) Replaces the entry for the specified key only if it is currently mapped to some value.
public Map<K, V>	retainAll(Iterable<? extends Tuple2<K, V>> Elements to be kept. elements) Redeclares io.vavr.collection.Traversable.retainAll. Keeps all occurrences of the given elements from this.
public Map<K, V>	scan(Tuple2<K, V> neutral element for the operator op zero, BiFunction<? super Tuple2<K, V>, ? super Tuple2<K, V>, ? extends Tuple2<K, V>> the associative operator for the scan operation) Redeclares io.vavr.collection.Traversable.scan. Computes a prefix scan of the elements of the collection.
public default <U> Seq<U>	scanLeft(U the initial value zero, BiFunction<? super U, ? super Tuple2<K, V>, ? extends U> the binary operator applied to the intermediate result and the element operation) Implements io.vavr.collection.Traversable.scanLeft. Produces a collection containing cumulative results of applying the operator going left to right.
public default <U> Seq<U>	scanRight(U the initial value zero, BiFunction<? super Tuple2<K, V>, ? super U, ? extends U> the binary operator applied to the intermediate result and the element operation) Implements io.vavr.collection.Traversable.scanRight. Produces a collection containing cumulative results of applying the operator going right to left.
public int	size() Redeclares as abstract: io.vavr.collection.Traversable.size. Computes the number of elements of this Traversable.
public Iterator<? extends Map<K, V>>	slideBy(Function<? super Tuple2<K, V>, ?> A function which classifies elements into classes classifier) Redeclares io.vavr.collection.Traversable.slideBy. Slides a non-overlapping window of a variable size over this `Traversable`.
public Iterator<? extends Map<K, V>>	sliding(int a positive window size size) Redeclares io.vavr.collection.Traversable.sliding. Slides a window of a specific `size` and step size 1 over this `Traversable` by calling `sliding(int, int)`.
public Iterator<? extends Map<K, V>>	sliding(int a positive window size size, int a positive step size step) Redeclares io.vavr.collection.Traversable.sliding. Slides a window of a specific `size` and `step` size over this `Traversable`.
public Tuple2<? extends Map<K, V>, ? extends Map<K, V>>	span(Predicate<? super Tuple2<K, V>> A predicate. predicate) Redeclares io.vavr.collection.Traversable.span. Returns a tuple where the first element is the longest prefix of elements that satisfy the given `predicate` and the second element is the remainder.
public Map<K, V>	tail() Redeclares io.vavr.collection.Traversable.tail. Drops the first element of a non-empty Traversable.
public Option<? extends Map<K, V>>	tailOption() Redeclares io.vavr.collection.Traversable.tailOption. Drops the first element of a non-empty Traversable and returns an `Option`.
public Map<K, V>	take(int The number of elements to take. n) Redeclares io.vavr.collection.Traversable.take. Takes the first n elements of this or all elements, if this length < n.
public Map<K, V>	takeRight(int The number of elements to take. n) Redeclares io.vavr.collection.Traversable.takeRight. Takes the last n elements of this or all elements, if this length < n.
public Map<K, V>	takeUntil(Predicate<? super Tuple2<K, V>> A condition tested subsequently for this elements. predicate) Redeclares io.vavr.collection.Traversable.takeUntil. Takes elements until the predicate holds for the current element.
public Map<K, V>	takeWhile(Predicate<? super Tuple2<K, V>> A condition tested subsequently for the contained elements. predicate) Redeclares io.vavr.collection.Traversable.takeWhile. Takes elements while the predicate holds for the current element.
public Map<K, V>	Returns: a new `java.util.Map` instance toJavaMap() Converts this Vavr `Map` to a `java.util.Map` while preserving characteristics like insertion order (`LinkedHashMap`) and sort order (`SortedMap`).
public default < Type of transformation result U> U	Returns: An instance of type `U` transform(Function<? super Map<K, V>, ? extends U> A transformation f) Transforms this `Map`.
public default Tuple2<Seq<K>, Seq<V>>	unzip()
public default <T1, T2> Tuple2<Seq<T1>, Seq<T2>>	unzip(BiFunction<? super K, ? super V, Tuple2<? extends T1, ? extends T2>> unzipper)
public default <T1, T2> Tuple2<Seq<T1>, Seq<T2>>	unzip(Function<? super Tuple2<K, V>, Tuple2<? extends T1, ? extends T2>> a function which converts elements of this to pairs unzipper) Implements io.vavr.collection.Traversable.unzip. Unzips this elements by mapping this elements to pairs which are subsequently split into two distinct sets.
public default <T1, T2, T3> Tuple3<Seq<T1>, Seq<T2>, Seq<T3>>	unzip3(BiFunction<? super K, ? super V, Tuple3<? extends T1, ? extends T2, ? extends T3>> unzipper)
public default <T1, T2, T3> Tuple3<Seq<T1>, Seq<T2>, Seq<T3>>	unzip3(Function<? super Tuple2<K, V>, Tuple3<? extends T1, ? extends T2, ? extends T3>> a function which converts elements of this to pairs unzipper) Implements io.vavr.collection.Traversable.unzip3. Unzips this elements by mapping this elements to triples which are subsequently split into three distinct sets.
public Seq<V>	Returns: a new `Seq` values() Returns a new `Seq` that contains the values of this `Map`.
public default Iterator<V>	Returns: a new `Iterator` valuesIterator() Returns the values in this map.
public default Function1<K, V>	Returns: a total function from K to T withDefault(Function<? super K, ? extends V> function to evaluate for all keys not present in the map defaultFunction) Deprecated Will be removed Turns this map from a partial function into a total function that returns a value computed by defaultFunction for all keys absent from the map.
public default Function1<K, V>	Returns: a total function from K to T withDefaultValue(V default value to return for all keys not present in the map defaultValue) Deprecated Will be removed Turns this map from a partial function into a total function that returns defaultValue for all keys absent from the map.
public default <U> Seq<Tuple2<Tuple2<K, V>, U>>	zip(Iterable<? extends U> The Iterable providing the second half of each result pair. that) Implements io.vavr.collection.Traversable.zip. Returns a traversable formed from this traversable and another Iterable collection by combining corresponding elements in pairs.
public default <U> Seq<Tuple2<Tuple2<K, V>, U>>	zipAll(Iterable<? extends U> The Iterable providing the second half of each result pair. that, Tuple2<K, V> The element to be used to fill up the result if this traversable is shorter than that. thisElem, U The element to be used to fill up the result if that is shorter than this traversable. thatElem) Implements io.vavr.collection.Traversable.zipAll. Returns a traversable formed from this traversable and another Iterable by combining corresponding elements in pairs.
public default <U, R> Seq<R>	zipWith(Iterable<? extends U> The Iterable providing the second parameter of the mapper. that, BiFunction<? super Tuple2<K, V>, ? super U, ? extends R> a mapper. mapper) Implements io.vavr.collection.Traversable.zipWith. Returns a traversable formed from this traversable and another Iterable collection by mapping elements.
public default Seq<Tuple2<Tuple2<K, V>, Integer>>	zipWithIndex() Implements io.vavr.collection.Traversable.zipWithIndex. Zips this traversable with its indices.
public default <U> Seq<U>	zipWithIndex(BiFunction<? super Tuple2<K, V>, ? super Integer, ? extends U> a mapper. mapper) Implements io.vavr.collection.Traversable.zipWithIndex. Zips this traversable with its indices by applying mapper provided.

public Interface Map<K, V>

Field Summary

Method Summary