A map with every entry of this map whose item is non-null.

A stream that produces every element produced by this stream exactly once. Duplicate elements of this stream are eliminated. Two elements are considered distinct unless they are both null, or unless they are both non-null and equal.

For example:

String("hello world".distinct)

is the string "helo wrd".

This is a lazy operation and the resulting stream reflects changes to this stream.

The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that:

• if x==y then x.hash==y.hash.

Therefore, a class which refines Object.equals() must also refine hash.

In general, hash values vary between platforms and between executions of the same program.

Note that when executing on a Java Virtual Machine, the 64-bit Integer value returned by an implementation of hash is truncated to a 32-bit integer value by removal of the 32 highest order bits, before returning the value to the caller.

A Collection containing the items stored in this map. An element can be stored under more than one key in the map, and so it can occur more than once in the resulting collection.

A Collection containing the keys of this map.

A shallow copy of this map, that is, a map with the same entries as this map, which do not change if the entries in this map change.

Determines if the given value is an Entry belonging to this map.

Produces a stream containing the elements of this stream, in the order in which they occur in this stream, after replacing every null element in the stream with the given default value. The value null does not ocur in the resulting stream.

For example, the expression

{ "123", "abc", "456" }.map(parseInteger).defaultNullElements(0)

results in the stream { 123, 0, 456 }.

Produces a map containing the elements of this map, after replacing every null item in the map with the given default value. The item null does not ocur in the resulting map.

Determines if there is an entry in this map with the given key.

Two maps are considered equal iff they have the same entry sets. The entry set of a Map is the set of Entrys belonging to the map. Therefore, the maps are equal iff they have same set of keys, and for every key in the key set, the maps have equal items.

Produces a map by applying a filtering() function to the keys of this map. This is a lazy operation, returning a view of this map.

Returns the item of the entry with the given key, or null if there is no entry with the given key in this map.

Returns the item of the entry with the given key, or the given default if there is no entry with the given key in this map.

For maps with non-null items, the expression:

map.getOrDefault(key, def)

is equivalent to this common idiom:

map[key] else def

However, when the map has null items, getOrDefault() will preserve them.

Note that high-quality implementations of Map should refine this default implementation.

Invert this map, producing a new immutable map where the keys of the new map are the non-null items of this map, and each item of the new map is a nonempty sequence of keys of this map.

For example, the expression:

{ "fee", "fi", "fo", "fum", "foo" }
   .tabulate(String.size)
   .inverse()

produces the map { 2->["fo", "fi"], 3->[ "fum", "fee", "foo"] }.

The order of keys in the key sequences is not defined and should not be relied upon.

This is an eager operation, and the resulting map does not reflect changes to this map.

Produces a map with the same keys as this map. For every key, the item is the result of applying the given transformation function to its associated item in this map. This is a lazy operation, returning a view of this map.

Produces a map whose keys are the union of the keys of this map, with the keys of the given map. For any given key in the resulting map, its associated item is the item associated with the key in the given map, if any, or the item associated with the key in this map otherwise.

That is, for any key in the resulting patched map:

map.patch(other)[key] == other.getOrDefault(key, map[key])

This is a lazy operation producing a view of this map and the given map.