IMap

All Superinterfaces:

Function<K,V>, ICollection<IMap<K,V>,IEntry<K,V>>, Iterable<IEntry<K,V>>

All Known Subinterfaces:

IDiffMap<K,V>, IDiffSortedMap<K,V>, ISortedMap<K,V>

All Known Implementing Classes:

DiffMap, DurableMap, FloatMap, IntMap, LinearMap, Map, SortedMap
```
public interface IMap<K,V>
extends ICollection<IMap<K,V>,IEntry<K,V>>, Function<K,V>
```

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default V`	`apply(K k)`
`default boolean`	`contains(K key)`
`default boolean`	`containsAll(IMap<K,?> map)`
`default boolean`	`containsAll(ISet<K> set)`
`default boolean`	`containsAny(IMap<K,?> map)`
`default boolean`	`containsAny(ISet<K> set)`
`default IMap<K,V>`	`difference(IMap<K,?> m)`
`default IMap<K,V>`	`difference(ISet<K> keys)`
`default IList<IEntry<K,V>>`	`entries()`
`default boolean`	`equals(IMap<K,V> m, BiPredicate<V,V> equals)`
`default IMap<K,V>`	`forked()` This returns a data structure which is forked, which is equivalent to Clojure's persistent data structures, also sometimes called functional or immutable.
`default Optional<V>`	`get(K key)`
`V`	`get(K key, V defaultValue)`
`default V`	`getOrCreate(K key, Supplier<V> f)`
`default Iterator<IEntry.WithHash<K,V>>`	`hashSortedEntries()`
`OptionalLong`	`indexOf(K key)`
`default IMap<K,V>`	`intersection(IMap<K,?> m)`
`default IMap<K,V>`	`intersection(ISet<K> keys)`
`default boolean`	`isLinear()`
`default Iterator<IEntry<K,V>>`	`iterator()`
`BiPredicate<K,K>`	`keyEquality()`
`ToLongFunction<K>`	`keyHash()`
`default ISet<K>`	`keys()`
`default IMap<K,V>`	`linear()` This returns a data structure which is linear, or temporarily mutable.
`default <U> IMap<K,U>`	`mapValues(BiFunction<K,V,U> f)`
`default IMap<K,V>`	`merge(IMap<K,V> b, BinaryOperator<V> mergeFn)`
`default IMap<K,V>`	`put(K key, V value)`
`default IMap<K,V>`	`put(K key, V value, BinaryOperator<V> merge)`
`default IMap<K,V>`	`remove(K key)`
`default DurableMap<K,V>`	`save(IDurableEncoding encoding, Path directory, double diffMergeThreshold)`
`default IList<? extends IMap<K,V>>`	`split(int parts)` Splits the collection into roughly even pieces, for parallel processing.
`default Spliterator<IEntry<K,V>>`	`spliterator()`
`default Stream<IEntry<K,V>>`	`stream()`
`default Map<K,V>`	`toMap()`
`default IMap<K,V>`	`union(IMap<K,V> m)`
`default IMap<K,V>`	`update(K key, UnaryOperator<V> update)`
`default IList<V>`	`values()`

Methods inherited from interface io.lacuna.bifurcan.ICollection
clone, nth, nth, save, size

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface java.util.function.Function
andThen, compose, identity

- Method Detail
  - keyHash
```
ToLongFunction<K> keyHash()
```
    Returns:
    
    the hash function used by the map
  - keyEquality
```
BiPredicate<K,K> keyEquality()
```
    Returns:
    
    the key equality semantics used by the map
  - get
```
V get(K key,
      V defaultValue)
```
    Returns:
    
    the value under key, or defaultValue if there is no such key
  - get
```
default Optional<V> get(K key)
```
    Returns:
    
    an Optional containing the value under key, or nothing if the value is null or is not contained within the map.
  - getOrCreate
```
default V getOrCreate(K key,
                      Supplier<V> f)
```
    Returns:
    
    the value under key, or one generated by f if there is no such key
  - contains
```
default boolean contains(K key)
```
    Returns:
    
    true if key is in the map, false otherwise
  - entries
```
default IList<IEntry<K,V>> entries()
```
    Returns:
    
    a list containing all the entries within the map
  - indexOf
```
OptionalLong indexOf(K key)
```
    Returns:
    
    the index of key within the collection, if it's present
  - keys
```
default ISet<K> keys()
```
    Returns:
    
    a set representing all keys in the map
  - values
```
default IList<V> values()
```
    Returns:
    
    a list representing all values in the map
  - mapValues
```
default <U> IMap<K,U> mapValues(BiFunction<K,V,U> f)
```
    Type Parameters:
    
    U - the new type of the values
    
    Parameters:
    
    f - a function which transforms the values
    
    Returns:
    
    a transformed map which shares the same equality semantics
  - containsAll
```
default boolean containsAll(ISet<K> set)
```
    Returns:
    
    true if this map contains all elements in set
  - containsAll
```
default boolean containsAll(IMap<K,?> map)
```
    Returns:
    
    true if this map contains all keys in map
  - containsAny
```
default boolean containsAny(ISet<K> set)
```
    Returns:
    
    true if this map contains any element in set
  - containsAny
```
default boolean containsAny(IMap<K,?> map)
```
    Returns:
    
    true if this map contains any element in map
  - isLinear
```
default boolean isLinear()
```
    Specified by:
    
    isLinear in interface ICollection<IMap<K,V>,IEntry<K,V>>
    
    Returns:
    
    true, if the collection is linear
  - toMap
```
default Map<K,V> toMap()
```
    Returns:
    
    the collection, represented as a normal Java map, which will throw UnsupportedOperationException on writes
  - iterator
```
default Iterator<IEntry<K,V>> iterator()
```
    Specified by:
    
    iterator in interface Iterable<IEntry<K,V>>
    
    Returns:
    
    an iterator over all entries in the map
  - hashSortedEntries
```
default Iterator<IEntry.WithHash<K,V>> hashSortedEntries()
```
    Returns:
    
    an iterator over all entries, sorted by their hash
  - stream
```
default Stream<IEntry<K,V>> stream()
```
    Returns:
    
    a Stream, representing the entries in the map
  - spliterator
```
default Spliterator<IEntry<K,V>> spliterator()
```
    Specified by:
    
    spliterator in interface Iterable<IEntry<K,V>>
  - merge
```
default IMap<K,V> merge(IMap<K,V> b,
                        BinaryOperator<V> mergeFn)
```
    Parameters:
    
    b - another map
    
    mergeFn - a function which, in the case of key collisions, takes two values and returns the merged result
    
    Returns:
    
    a new map representing the merger of the two maps
  - difference
```
default IMap<K,V> difference(ISet<K> keys)
```
    Returns:
    
    a new map representing the current map, less the keys in keys
  - intersection
```
default IMap<K,V> intersection(ISet<K> keys)
```
    Returns:
    
    a new map representing the current map, but only with the keys in keys
  - union
```
default IMap<K,V> union(IMap<K,V> m)
```
    Returns:
    
    a combined map, with the values from m shadowing those in this amp
  - difference
```
default IMap<K,V> difference(IMap<K,?> m)
```
    Returns:
    
    a new map representing the current map, less the keys in m
  - intersection
```
default IMap<K,V> intersection(IMap<K,?> m)
```
    Returns:
    
    a new map representing the current map, but only with the keys in m
  - put
```
default IMap<K,V> put(K key,
                      V value,
                      BinaryOperator<V> merge)
```
    Parameters:
    
    merge - a function which will be invoked if there is a pre-existing value under key, with the current value as the first argument and new value as the second, to determine the combined result
    
    Returns:
    
    an updated map with value under key
  - update
```
default IMap<K,V> update(K key,
                         UnaryOperator<V> update)
```
    Parameters:
    
    update - a function which takes the existing value, or null if none exists, and returns an updated value.
    
    Returns:
    
    an updated map with update(value) under key.
  - put
```
default IMap<K,V> put(K key,
                      V value)
```
    Returns:
    
    an updated map with value stored under key
  - remove
```
default IMap<K,V> remove(K key)
```
    Returns:
    
    an updated map that does not contain key
  - forked
```
default IMap<K,V> forked()
```
    Description copied from interface: ICollection
    
    This returns a data structure which is forked, which is equivalent to Clojure's persistent data structures, also sometimes called functional or immutable. This is called "forked" because it means that multiple functions can make divergent changes to the data structure without affecting each other.
    If only a single function or scope uses the data structure, it can be left as a linear data structure, which can have significant performance benefits.
    If the data structure is already forked, it will simply return itself.
    
    Specified by:
    
    forked in interface ICollection<IMap<K,V>,IEntry<K,V>>
    
    Returns:
    
    a forked form of the data structure
  - linear
```
default IMap<K,V> linear()
```
    Description copied from interface: ICollection
    
    This returns a data structure which is linear, or temporarily mutable. The term "linear", as used here, does not completely align with the formal definition of linear types as used in type theory. It is meant to describe the linear dataflow of the method calls, and as a converse to "forked" data structures.
    If ICollection.forked() is called on a linear collection, all references to that linear collection should be discarded.
    If the data structure is already linear, it will simply return itself.
    
    Specified by:
    
    linear in interface ICollection<IMap<K,V>,IEntry<K,V>>
    
    Returns:
    
    a linear form of this data structure
  - split
```
default IList<? extends IMap<K,V>> split(int parts)
```
    Description copied from interface: ICollection
    
    Splits the collection into roughly even pieces, for parallel processing. Depending on the size and contents of the collection, this function may not return exactly parts subsets.
    
    Specified by:
    
    split in interface ICollection<IMap<K,V>,IEntry<K,V>>
    
    Parameters:
    
    parts - the target number of pieces
    
    Returns:
    
    a list containing subsets of the collection.
  - equals
```
default boolean equals(IMap<K,V> m,
                       BiPredicate<V,V> equals)
```
    Parameters:
    
    m - another map
    
    equals - a predicate which checks value equalities
    
    Returns:
    
    true, if the maps are equivalent
  - apply
```
default V apply(K k)
```
    Specified by:
    
    apply in interface Function<K,V>
    
    Returns:
    
    the corresponding value
    
    Throws:
    
    IllegalArgumentException - if no such key is inside the map
  - save
```
default DurableMap<K,V> save(IDurableEncoding encoding,
                             Path directory,
                             double diffMergeThreshold)
```

Interface IMap<K,V>

Method Summary

Methods inherited from interface io.lacuna.bifurcan.ICollection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.function.Function

Method Detail

keyHash

keyEquality

get

get

getOrCreate

contains

entries

indexOf

keys

values

mapValues

containsAll

containsAll

containsAny

containsAny

isLinear

toMap

iterator

hashSortedEntries

stream

spliterator

merge

difference

intersection

union

difference

intersection

put

update

put

remove

forked

linear

split

equals

apply

save