public final class HashMap<K,V> extends Object implements Map<K,V>, Serializable
HashMap
implementation based on a
Hash array mapped trie (HAMT).Function1.Type<T1,R>
λ.Memoized
Modifier and Type | Method and Description |
---|---|
<K2,V2> HashMap<K2,V2> |
bimap(java.util.function.Function<? super K,? extends K2> keyMapper,
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. |
HashMap<K,V> |
clear()
Returns an empty version of this traversable, i.e.
|
static <K,V> java.util.stream.Collector<Tuple2<K,V>,ArrayList<Tuple2<K,V>>,HashMap<K,V>> |
collector()
|
boolean |
containsKey(K key)
Returns
true if this map contains a mapping for the specified key. |
boolean |
containsValue(V value)
Returns
true if this map maps one or more keys to the
specified value. |
HashMap<K,V> |
distinct()
Returns a new version of this which contains no duplicates.
|
HashMap<K,V> |
distinctBy(Comparator<? super Tuple2<K,V>> comparator)
Returns a new version of this which contains no duplicates.
|
<U> HashMap<K,V> |
distinctBy(java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
Returns a new version of this which contains no duplicates.
|
HashMap<K,V> |
drop(long n)
Drops the first n elements of this or all elements, if this length < n.
|
HashMap<K,V> |
dropRight(long n)
Drops the last n elements of this or all elements, if this length < n.
|
HashMap<K,V> |
dropUntil(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Drops elements until the predicate holds for the current element.
|
HashMap<K,V> |
dropWhile(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Drops elements while the predicate holds for the current element.
|
static <K,V> HashMap<K,V> |
empty() |
boolean |
equals(Object o)
Clarifies that values have a proper equals() method implemented.
|
static <K,V> HashMap<K,V> |
fill(int n,
java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)
Returns an HashMap containing
n values supplied by a given Supplier s . |
HashMap<K,V> |
filter(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Returns a new traversable consisting of all elements which satisfy the given predicate.
|
<K2,V2> HashMap<K2,V2> |
flatMap(java.util.function.BiFunction<? super K,? super V,? extends Iterable<Tuple2<K2,V2>>> mapper)
FlatMaps this
Map to a new Map with different component type. |
<U> U |
foldRight(U zero,
java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> f)
Accumulates the elements of this Traversable by successively calling the given function
f from the right,
starting with a value zero of type B. |
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. |
<C> Map<C,HashMap<K,V>> |
groupBy(java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
Groups this elements by classifying the elements.
|
Iterator<HashMap<K,V>> |
grouped(long size)
Groups this
Traversable into fixed size blocks. |
boolean |
hasDefiniteSize()
Checks if this Traversable is known to have a finite size.
|
int |
hashCode()
Clarifies that values have a proper hashCode() method implemented.
|
Tuple2<K,V> |
head()
Returns the first element of a non-empty Traversable.
|
Option<Tuple2<K,V>> |
headOption()
Returns the first element of a non-empty Traversable as
Option . |
HashMap<K,V> |
init()
Dual of Traversable.tail(), returning all elements except the last.
|
Option<HashMap<K,V>> |
initOption()
Dual of Traversable.tailOption(), returning all elements except the last as
Option . |
boolean |
isEmpty()
Checks if this Traversable is empty.
|
boolean |
isTraversableAgain()
Checks if this Traversable can be repeatedly traversed.
|
Iterator<Tuple2<K,V>> |
iterator()
An iterator by means of head() and tail().
|
Set<K> |
keySet()
Returns the keys contained in this map.
|
int |
length()
Computes the number of elements of this Traversable.
|
<K2,V2> HashMap<K2,V2> |
map(java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
Maps the entries of this
Map to form a new Map . |
<V2> HashMap<K,V2> |
mapValues(java.util.function.Function<? super V,? extends V2> valueMapper)
Maps the values of this
Map while preserving the corresponding keys. |
Match.MatchValue.Of<HashMap<K,V>> |
match()
Provides syntactic sugar for
Match.MatchValue.Of . |
HashMap<K,V> |
merge(Map<? extends K,? extends V> that)
Creates a new map which by merging the entries of
this map and that map. |
<U extends V> |
merge(Map<? extends K,U> that,
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> HashMap<K,V> |
of(K key,
V value)
Returns a singleton
HashMap , i.e. |
static <K,V> HashMap<K,V> |
of(Object... pairs)
Creates a HashMap of the given list of key-value pairs.
|
static <K,V> HashMap<K,V> |
of(Tuple2<? extends K,? extends V> entry)
Returns a singleton
HashMap , i.e. |
static <K,V> HashMap<K,V> |
ofAll(Map<? extends K,? extends V> map)
Returns a
HashMap , from a source java.util.Map. |
static <K,V> HashMap<K,V> |
ofEntries(Iterable<? extends Tuple2<? extends K,? extends V>> entries)
Creates a HashMap of the given entries.
|
static <K,V> HashMap<K,V> |
ofEntries(Map.Entry<? extends K,? extends V>... entries)
Creates a HashMap of the given entries.
|
static <K,V> HashMap<K,V> |
ofEntries(Tuple2<? extends K,? extends V>... entries)
Creates a HashMap of the given entries.
|
Tuple2<HashMap<K,V>,HashMap<K,V>> |
partition(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Creates a partition of this
Traversable by splitting this elements in two in distinct tarversables
according to a predicate. |
HashMap<K,V> |
peek(java.util.function.Consumer<? super Tuple2<K,V>> action)
Performs the given
action on the first element if this is an eager implementation. |
HashMap<K,V> |
put(K key,
V value)
Associates the specified value with the specified key in this map.
|
HashMap<K,V> |
put(Tuple2<? extends K,? extends V> entry)
Convenience method for
put(entry._1, entry._2) . |
HashMap<K,V> |
remove(K key)
Removes the mapping for a key from this map if it is present.
|
HashMap<K,V> |
removeAll(Iterable<? extends K> keys)
Removes the mapping for a key from this map if it is present.
|
HashMap<K,V> |
replace(Tuple2<K,V> currentElement,
Tuple2<K,V> newElement)
Replaces the first occurrence (if exists) of the given currentElement with newElement.
|
HashMap<K,V> |
replaceAll(Tuple2<K,V> currentElement,
Tuple2<K,V> newElement)
Replaces all occurrences of the given currentElement with newElement.
|
HashMap<K,V> |
retainAll(Iterable<? extends Tuple2<K,V>> elements)
Keeps all occurrences of the given elements from this.
|
HashMap<K,V> |
scan(Tuple2<K,V> zero,
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 the collection.
|
<U> Seq<U> |
scanLeft(U zero,
java.util.function.BiFunction<? super U,? super Tuple2<K,V>,? extends U> operation)
Produces a collection containing cumulative results of applying the
operator going left to right.
|
<U> Seq<U> |
scanRight(U zero,
java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> operation)
Produces a collection containing cumulative results of applying the
operator going right to left.
|
int |
size()
Computes the number of elements of this Traversable.
|
Iterator<HashMap<K,V>> |
sliding(long size)
Slides a window of a specific
size and step size 1 over this Traversable by calling
Traversable.sliding(long, long) . |
Iterator<HashMap<K,V>> |
sliding(long size,
long step)
Slides a window of a specific
size and step size over this Traversable . |
Tuple2<HashMap<K,V>,HashMap<K,V>> |
span(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
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. |
String |
stringPrefix()
Returns the name of this Value type, which is used by toString().
|
static <K,V> HashMap<K,V> |
tabulate(int n,
java.util.function.Function<? super Integer,? extends Tuple2<? extends K,? extends V>> f)
Returns an HashMap containing
n values of a given Function f
over a range of integer values from 0 to n - 1 . |
HashMap<K,V> |
tail()
Drops the first element of a non-empty Traversable.
|
Option<HashMap<K,V>> |
tailOption()
Drops the first element of a non-empty Traversable and returns an
Option . |
HashMap<K,V> |
take(long n)
Takes the first n elements of this or all elements, if this length < n.
|
HashMap<K,V> |
takeRight(long n)
Takes the last n elements of this or all elements, if this length < n.
|
HashMap<K,V> |
takeUntil(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Takes elements until the predicate holds for the current element.
|
HashMap<K,V> |
takeWhile(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Takes elements while the predicate holds for the current element.
|
String |
toString()
Clarifies that values have a proper toString() method implemented.
|
Seq<V> |
values() |
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
apply, contains, flatMap, forEach, map, spliterator, transform, traverse, unzip, unzip, unzip3, unzip3, zip, zipAll, zipWithIndex
average, containsAll, count, existsUnique, find, findLast, foldLeft, get, hash, isSingleValued, last, lastOption, max, maxBy, maxBy, min, minBy, minBy, mkString, mkString, mkString, product, reduceLeft, reduceLeftOption, reduceRight, reduceRightOption, sum
fold, reduce, reduceOption
corresponds, eq, exists, forAll, forEach, getOption, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, isDefined, out, out, stderr, stdout, toArray, toCharSeq, toJavaArray, toJavaArray, toJavaList, toJavaMap, toJavaOptional, toJavaSet, toJavaStream, toLeft, toLeft, toList, toMap, toOption, toQueue, toRight, toRight, toSet, toStack, toStream, toTree, toTry, toTry, toVector
andThen, arity, compose, curried, getType, identity, lift, memoized, of, reversed, tupled
isApplicableTo, isApplicableToTypes, isMemoized
public static <K,V> java.util.stream.Collector<Tuple2<K,V>,ArrayList<Tuple2<K,V>>,HashMap<K,V>> collector()
Collector
which may be used in conjunction with
Stream.collect(java.util.stream.Collector)
to obtain a HashMap
.K
- The key typeV
- The value typeHashMap
Collector.public static <K,V> HashMap<K,V> empty()
public static <K,V> HashMap<K,V> of(Tuple2<? extends K,? extends V> entry)
HashMap
, i.e. a HashMap
of one element.K
- The key typeV
- The value typeentry
- A map entry.public static <K,V> HashMap<K,V> ofAll(Map<? extends K,? extends V> map)
HashMap
, from a source java.util.Map.K
- The key typeV
- The value typemap
- A map entry.public static <K,V> HashMap<K,V> of(K key, V value)
HashMap
, i.e. a HashMap
of one element.K
- The key typeV
- The value typekey
- A singleton map key.value
- A singleton map value.public static <K,V> HashMap<K,V> of(Object... pairs)
K
- The key typeV
- The value typepairs
- A list of key-value pairspublic static <K,V> HashMap<K,V> tabulate(int n, java.util.function.Function<? super Integer,? extends Tuple2<? extends K,? extends V>> f)
n
values of a given Function f
over a range of integer values from 0 to n - 1
.K
- The key typeV
- The value typen
- The number of elements in the HashMapf
- The Function computing element valuesf(0),f(1), ..., f(n - 1)
NullPointerException
- if f
is nullpublic static <K,V> HashMap<K,V> fill(int n, java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)
n
values supplied by a given Supplier s
.K
- The key typeV
- The value typen
- The number of elements in the HashMaps
- The Supplier computing element valuesn
, where each element contains the result supplied by s
.NullPointerException
- if s
is null@SafeVarargs public static <K,V> HashMap<K,V> ofEntries(Map.Entry<? extends K,? extends V>... entries)
K
- The key typeV
- The value typeentries
- Map entries@SafeVarargs public static <K,V> HashMap<K,V> ofEntries(Tuple2<? extends K,? extends V>... entries)
K
- The key typeV
- The value typeentries
- Map entriespublic static <K,V> HashMap<K,V> ofEntries(Iterable<? extends Tuple2<? extends K,? extends V>> entries)
K
- The key typeV
- The value typeentries
- Map entriespublic <K2,V2> HashMap<K2,V2> bimap(java.util.function.Function<? super K,? extends K2> keyMapper, java.util.function.Function<? super V,? extends V2> valueMapper)
Map
Map
to a new Map
with different component type by applying a function to its elements.bimap
in interface Map<K,V>
K2
- key's component type of the map resultV2
- value's component type of the map resultkeyMapper
- 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
Map
public HashMap<K,V> clear()
Traversable
this.clear().isEmpty() == true
.public boolean containsKey(K key)
Map
true
if this map contains a mapping for the specified key.containsKey
in interface Map<K,V>
key
- key whose presence in this map is to be testedtrue
if this map contains a mapping for the specified keypublic boolean containsValue(V value)
Map
true
if this map maps one or more keys to the
specified value. This operation will require time linear in the map size.containsValue
in interface Map<K,V>
value
- value whose presence in this map is to be testedtrue
if this map maps one or more keys to the
specified valuepublic HashMap<K,V> distinct()
Traversable
equals
.public HashMap<K,V> distinctBy(Comparator<? super Tuple2<K,V>> comparator)
Traversable
comparator
.distinctBy
in interface Map<K,V>
distinctBy
in interface Traversable<Tuple2<K,V>>
comparator
- A comparatorTraversable
containing this elements without duplicatespublic <U> HashMap<K,V> distinctBy(java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
Traversable
equals
.
The elements of the result are determined in the order of their occurrence - first match wins.
distinctBy
in interface Map<K,V>
distinctBy
in interface Traversable<Tuple2<K,V>>
U
- key typekeyExtractor
- A key extractorTraversable
containing this elements without duplicatespublic HashMap<K,V> drop(long n)
Traversable
public HashMap<K,V> dropRight(long n)
Traversable
dropRight
in interface Map<K,V>
dropRight
in interface Traversable<Tuple2<K,V>>
n
- The number of elements to drop.public HashMap<K,V> dropUntil(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Traversable
Note: This is essentially the same as dropWhile(predicate.negate())
. It is intended to be used with
method references, which cannot be negated directly.
dropUntil
in interface Map<K,V>
dropUntil
in interface Traversable<Tuple2<K,V>>
predicate
- A condition tested subsequently for this elements.public HashMap<K,V> dropWhile(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Traversable
dropWhile
in interface Map<K,V>
dropWhile
in interface Traversable<Tuple2<K,V>>
predicate
- A condition tested subsequently for this elements starting with the first.public HashMap<K,V> filter(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Traversable
public <K2,V2> HashMap<K2,V2> flatMap(java.util.function.BiFunction<? super K,? super V,? extends Iterable<Tuple2<K2,V2>>> mapper)
Map
Map
to a new Map
with different component type.public <U> U foldRight(U zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> f)
Traversable
f
from the right,
starting with a value zero
of type B.
Example: List.of("a", "b", "c").foldRight("", (x, xs) -> x + xs) = "abc"
foldRight
in interface Foldable<Tuple2<K,V>>
foldRight
in interface Traversable<Tuple2<K,V>>
U
- Result type of the accumulator.zero
- Value to start the accumulation with.f
- The accumulator function.public Option<V> get(K key)
Map
Some
of value to which the specified key
is mapped, or None
if this map contains no mapping for the key.public <C> Map<C,HashMap<K,V>> groupBy(java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
Traversable
public Iterator<HashMap<K,V>> grouped(long size)
Traversable
Traversable
into fixed size blocks.
Let length be the length of this Iterable. Then grouped is defined as follows:
this.isEmpty()
, the resulting Iterator
is empty.size <= length
, the resulting Iterator
will contain length / size
blocks of size
size
and maybe a non-empty block of size length % size
, if there are remaining elements.size > length
, the resulting Iterator
will contain one block of size length
.
[].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]]
Please note that grouped(int)
is a special case of Traversable.sliding(long, long), i.e.
grouped(size)
is the same as sliding(size, size)
.public boolean hasDefiniteSize()
Traversable
This method should be implemented by classes only, i.e. not by interfaces.
hasDefiniteSize
in interface Traversable<Tuple2<K,V>>
public Tuple2<K,V> head()
Traversable
head
in interface Traversable<Tuple2<K,V>>
public Option<Tuple2<K,V>> headOption()
Traversable
Option
.headOption
in interface Traversable<Tuple2<K,V>>
Some(element)
or None
if this is empty.public HashMap<K,V> init()
Traversable
public Option<HashMap<K,V>> initOption()
Traversable
Option
.initOption
in interface Map<K,V>
initOption
in interface Traversable<Tuple2<K,V>>
Some(traversable)
or None
if this is empty.public boolean isEmpty()
Traversable
public boolean isTraversableAgain()
Traversable
This method should be implemented by classes only, i.e. not by interfaces.
isTraversableAgain
in interface Traversable<Tuple2<K,V>>
public Iterator<Tuple2<K,V>> iterator()
Traversable
public Set<K> keySet()
Map
public int length()
Traversable
Same as Traversable.size()
.
public <K2,V2> HashMap<K2,V2> map(java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
Map
Map
to form a new Map
.public <V2> HashMap<K,V2> mapValues(java.util.function.Function<? super V,? extends V2> valueMapper)
Map
Map
while preserving the corresponding keys.public Match.MatchValue.Of<HashMap<K,V>> match()
Value
Match.MatchValue.Of
.
We write
value.match()
.when(...).then(...)
.get();
instead of
Match.of(value)
.when(...).then(...)
.get();
public HashMap<K,V> merge(Map<? extends K,? extends V> that)
Map
this
map and that
map.
If collisions occur, the value of this
map is taken.
public <U extends V> HashMap<K,V> merge(Map<? extends K,U> that, java.util.function.BiFunction<? super V,? super U,? extends V> collisionResolution)
Map
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.
public Tuple2<HashMap<K,V>,HashMap<K,V>> partition(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Traversable
Traversable
by splitting this elements in two in distinct tarversables
according to a predicate.partition
in interface Map<K,V>
partition
in interface Traversable<Tuple2<K,V>>
predicate
- A predicate which classifies an element if it is in the first or the second traversable.Traversable
contains all elements that satisfy the given predicate
, the second Traversable
contains all elements that don't. The original order of elements is preserved.public HashMap<K,V> peek(java.util.function.Consumer<? super Tuple2<K,V>> action)
Value
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.public HashMap<K,V> put(K key, V value)
Map
public HashMap<K,V> put(Tuple2<? extends K,? extends V> entry)
Map
put(entry._1, entry._2)
.public HashMap<K,V> remove(K key)
Map
public HashMap<K,V> removeAll(Iterable<? extends K> keys)
Map
public HashMap<K,V> replace(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
Traversable
replace
in interface Map<K,V>
replace
in interface Traversable<Tuple2<K,V>>
currentElement
- An element to be substituted.newElement
- A replacement for currentElement.public HashMap<K,V> replaceAll(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
Traversable
replaceAll
in interface Map<K,V>
replaceAll
in interface Traversable<Tuple2<K,V>>
currentElement
- An element to be substituted.newElement
- A replacement for currentElement.public HashMap<K,V> retainAll(Iterable<? extends Tuple2<K,V>> elements)
Traversable
public HashMap<K,V> scan(Tuple2<K,V> zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
Traversable
scan
in interface Map<K,V>
scan
in interface Traversable<Tuple2<K,V>>
zero
- neutral element for the operator opoperation
- the associative operator for the scanpublic <U> Seq<U> scanLeft(U zero, java.util.function.BiFunction<? super U,? super Tuple2<K,V>,? extends U> operation)
Traversable
scanLeft
in interface Map<K,V>
scanLeft
in interface Traversable<Tuple2<K,V>>
U
- the type of the elements in the resulting collectionzero
- the initial valueoperation
- the binary operator applied to the intermediate result and the elementpublic <U> Seq<U> scanRight(U zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> operation)
Traversable
scanRight
in interface Map<K,V>
scanRight
in interface Traversable<Tuple2<K,V>>
U
- the type of the elements in the resulting collectionzero
- the initial valueoperation
- the binary operator applied to the intermediate result and the elementpublic int size()
Traversable
Same as Traversable.length()
.
public Iterator<HashMap<K,V>> sliding(long size)
Traversable
size
and step size 1 over this Traversable
by calling
Traversable.sliding(long, long)
.public Iterator<HashMap<K,V>> sliding(long size, long step)
Traversable
size
and step
size 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]]
public Tuple2<HashMap<K,V>,HashMap<K,V>> span(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Traversable
predicate
and the second element is the remainder.public HashMap<K,V> tail()
Traversable
public Option<HashMap<K,V>> tailOption()
Traversable
Option
.tailOption
in interface Map<K,V>
tailOption
in interface Traversable<Tuple2<K,V>>
Some(traversable)
or None
if this is empty.public HashMap<K,V> take(long n)
Traversable
The result is equivalent to sublist(0, max(0, min(length(), n)))
but does not throw if n < 0
or
n > length()
.
In the case of n < 0
the empty instance is returned, in the case of n > length()
this is returned.
public HashMap<K,V> takeRight(long n)
Traversable
The result is equivalent to sublist(max(0, min(length(), length() - n)), n)
, i.e. takeRight will not
throw if n < 0
or n > length()
.
In the case of n < 0
the empty instance is returned, in the case of n > length()
this is returned.
public HashMap<K,V> takeUntil(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Traversable
Note: This is essentially the same as takeWhile(predicate.negate())
. It is intended to be used with
method references, which cannot be negated directly.
public HashMap<K,V> takeWhile(java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Traversable
takeWhile
in interface Map<K,V>
takeWhile
in interface Traversable<Tuple2<K,V>>
predicate
- A condition tested subsequently for the contained elements.public int hashCode()
Value
See Object.hashCode().
public boolean equals(Object o)
Value
public String stringPrefix()
Value
stringPrefix
in interface Value<Tuple2<K,V>>
public String toString()
Value
See Object.toString().
Copyright © 2016. All Rights Reserved.