LinearMap

java.lang.Object
- io.lacuna.bifurcan.LinearMap<K,V>

All Implemented Interfaces:

ICollection<IMap<K,V>,IEntry<K,V>>, IMap<K,V>, Cloneable, Iterable<IEntry<K,V>>, Function<K,V>
```
public class LinearMap<K,V>
extends Object
implements IMap<K,V>, Cloneable
```
A hash-map implementation which uses Robin Hood hashing for placement, and allows for customized hashing and equality semantics. Performance is equivalent to HashMap for lookups and construction, and superior in the case of poor hash distribution. Because entries are stored contiguously, performance of clone() and iteration is significantly better than HashMap.
The IMap.entries() method is O(1) and allows random access, returning an IList that proxies through to an underlying array. Partitioning this list is the most efficient way to process the collection in parallel.
However, LinearMap also exposes O(N) split(int) and merge(IMap, BinaryOperator) methods, which despite their asymptotic complexity can be quite fast in practice. The appropriate way to split this collection will depend on the use case.

Field Summary

Fields
Modifier and Type Field and Description

static int MAX_CAPACITY

Fields
Modifier and Type	Field and Description
`static int`	`MAX_CAPACITY`

Constructor Summary

Constructors
Constructor and Description
`LinearMap()`
`LinearMap(int initialCapacity)`
`LinearMap(int initialCapacity, ToLongFunction<K> hashFn, BiPredicate<K,K> equalsFn)`
`LinearMap(ToLongFunction<K> hashFn, BiPredicate<K,K> equalsFn)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`LinearMap<K,V>`	`clear()`
`LinearMap<K,V>`	`clone()`
`boolean`	`containsAll(IMap<K,?> map)`
`boolean`	`containsAll(ISet<K> set)`
`boolean`	`containsAny(IMap<K,?> map)`
`boolean`	`containsAny(ISet<K> set)`
`LinearMap<K,V>`	`difference(IMap<K,?> m)`
`IMap<K,V>`	`difference(ISet<K> keys)`
`boolean`	`equals(Object obj)`
`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.
`static <K,V> LinearMap<K,V>`	`from(Collection<Map.Entry<K,V>> collection)`
`static <K,V> LinearMap<K,V>`	`from(IMap<K,V> map)`
`static <K,V> LinearMap<K,V>`	`from(Iterable<IEntry<K,V>> entries)`
`static <K,V> LinearMap<K,V>`	`from(Iterator<IEntry<K,V>> iterator)`
`static <K,V> LinearMap<K,V>`	`from(Map<K,V> map)`
`V`	`get(K key, V defaultValue)`
`int`	`hashCode()`
`OptionalLong`	`indexOf(K key)`
`LinearMap<K,V>`	`intersection(IMap<K,?> m)`
`LinearMap<K,V>`	`intersection(ISet<K> keys)`
`boolean`	`isLinear()`
`BiPredicate<K,K>`	`keyEquality()`
`ToLongFunction<K>`	`keyHash()`
`ISet<K>`	`keys()`
`IMap<K,V>`	`linear()` This returns a data structure which is linear, or temporarily mutable.
`<U> LinearMap<K,U>`	`mapValues(BiFunction<K,V,U> f)`
`LinearMap<K,V>`	`merge(IMap<K,V> m, BinaryOperator<V> mergeFn)`
`IEntry<K,V>`	`nth(long index)`
`LinearMap<K,V>`	`put(K key, V value)`
`LinearMap<K,V>`	`put(K key, V value, BinaryOperator<V> merge)`
`LinearMap<K,V>`	`remove(K key)`
`long`	`size()`
`List<LinearMap<K,V>>`	`split(int parts)` Splits the collection into roughly even pieces, for parallel processing.
`String`	`toString()`
`LinearMap<K,V>`	`union(IMap<K,V> m)`
`LinearMap<K,V>`	`update(K key, UnaryOperator<V> update)`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.lacuna.bifurcan.IMap
apply, contains, entries, equals, get, getOrCreate, hashSortedEntries, iterator, save, spliterator, stream, toMap, values

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

Methods inherited from interface java.lang.Iterable
forEach

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

- Field Detail
  - MAX_CAPACITY
```
public static final int MAX_CAPACITY
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - LinearMap
```
public LinearMap()
```
  - LinearMap
```
public LinearMap(int initialCapacity)
```
    Parameters:
    
    initialCapacity - the initial capacity of the map
  - LinearMap
```
public LinearMap(ToLongFunction<K> hashFn,
                 BiPredicate<K,K> equalsFn)
```
    Parameters:
    
    hashFn - a function which yields the hash value of keys
    
    equalsFn - a function which checks equality of keys
  - LinearMap
```
public LinearMap(int initialCapacity,
                 ToLongFunction<K> hashFn,
                 BiPredicate<K,K> equalsFn)
```
    Parameters:
    
    initialCapacity - the initial capacity of the map
    
    hashFn - a function which yields the hash value of keys
    
    equalsFn - a function which checks equality of keys
- Method Detail
  - from
```
public static <K,V> LinearMap<K,V> from(Map<K,V> map)
```
    Returns:
    
    a copy of map
  - from
```
public static <K,V> LinearMap<K,V> from(IMap<K,V> map)
```
    Returns:
    
    a copy of map, with the same equality semantics
  - from
```
public static <K,V> LinearMap<K,V> from(Iterable<IEntry<K,V>> entries)
```
    Returns:
    
    a map representing all elements in entries
  - from
```
public static <K,V> LinearMap<K,V> from(Iterator<IEntry<K,V>> iterator)
```
    Returns:
    
    a map representing all remaining entries in iterator
  - from
```
public static <K,V> LinearMap<K,V> from(Collection<Map.Entry<K,V>> collection)
```
    Returns:
    
    a map representing the entries in collection
  - keyHash
```
public ToLongFunction<K> keyHash()
```
    Specified by:
    
    keyHash in interface IMap<K,V>
    
    Returns:
    
    the hash function used by the map
  - keyEquality
```
public BiPredicate<K,K> keyEquality()
```
    Specified by:
    
    keyEquality in interface IMap<K,V>
    
    Returns:
    
    the key equality semantics used by the map
  - put
```
public LinearMap<K,V> put(K key,
                          V value)
```
    Specified by:
    
    put in interface IMap<K,V>
    
    Returns:
    
    an updated map with value stored under key
  - put
```
public LinearMap<K,V> put(K key,
                          V value,
                          BinaryOperator<V> merge)
```
    Specified by:
    
    put in interface IMap<K,V>
    
    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
  - remove
```
public LinearMap<K,V> remove(K key)
```
    Specified by:
    
    remove in interface IMap<K,V>
    
    Returns:
    
    an updated map that does not contain key
  - clear
```
public LinearMap<K,V> clear()
```
  - mapValues
```
public <U> LinearMap<K,U> mapValues(BiFunction<K,V,U> f)
```
    Specified by:
    
    mapValues in interface IMap<K,V>
    
    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
  - get
```
public V get(K key,
             V defaultValue)
```
    Specified by:
    
    get in interface IMap<K,V>
    
    Returns:
    
    the value under key, or defaultValue if there is no such key
  - update
```
public LinearMap<K,V> update(K key,
                             UnaryOperator<V> update)
```
    Specified by:
    
    update in interface IMap<K,V>
    
    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.
  - keys
```
public ISet<K> keys()
```
    Specified by:
    
    keys in interface IMap<K,V>
    
    Returns:
    
    a set representing all keys in the map
  - indexOf
```
public OptionalLong indexOf(K key)
```
    Specified by:
    
    indexOf in interface IMap<K,V>
    
    Returns:
    
    the index of key within the collection, if it's present
  - nth
```
public IEntry<K,V> nth(long index)
```
    Specified by:
    
    nth in interface ICollection<IMap<K,V>,IEntry<K,V>>
    
    Returns:
    
    the element at idx
  - size
```
public long size()
```
    Specified by:
    
    size in interface ICollection<IMap<K,V>,IEntry<K,V>>
    
    Returns:
    
    the number of elements in the collection
  - isLinear
```
public boolean isLinear()
```
    Specified by:
    
    isLinear in interface ICollection<IMap<K,V>,IEntry<K,V>>
    
    Specified by:
    
    isLinear in interface IMap<K,V>
    
    Returns:
    
    true, if the collection is linear
  - forked
```
public 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>>
    
    Specified by:
    
    forked in interface IMap<K,V>
    
    Returns:
    
    a forked form of the data structure
  - linear
```
public 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>>
    
    Specified by:
    
    linear in interface IMap<K,V>
    
    Returns:
    
    a linear form of this data structure
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - clone
```
public LinearMap<K,V> clone()
```
    Specified by:
    
    clone in interface ICollection<IMap<K,V>,IEntry<K,V>>
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    a cloned copy of the collection
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - split
```
public List<LinearMap<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>>
    
    Specified by:
    
    split in interface IMap<K,V>
    
    Parameters:
    
    parts - the target number of pieces
    
    Returns:
    
    a list containing subsets of the collection.
  - union
```
public LinearMap<K,V> union(IMap<K,V> m)
```
    Specified by:
    
    union in interface IMap<K,V>
    
    Returns:
    
    a combined map, with the values from m shadowing those in this amp
  - merge
```
public LinearMap<K,V> merge(IMap<K,V> m,
                            BinaryOperator<V> mergeFn)
```
    Specified by:
    
    merge in interface IMap<K,V>
    
    Parameters:
    
    m - 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
```
public LinearMap<K,V> difference(IMap<K,?> m)
```
    Specified by:
    
    difference in interface IMap<K,V>
    
    Returns:
    
    a new map representing the current map, less the keys in m
  - difference
```
public IMap<K,V> difference(ISet<K> keys)
```
    Specified by:
    
    difference in interface IMap<K,V>
    
    Returns:
    
    a new map representing the current map, less the keys in keys
  - intersection
```
public LinearMap<K,V> intersection(IMap<K,?> m)
```
    Specified by:
    
    intersection in interface IMap<K,V>
    
    Returns:
    
    a new map representing the current map, but only with the keys in m
  - intersection
```
public LinearMap<K,V> intersection(ISet<K> keys)
```
    Specified by:
    
    intersection in interface IMap<K,V>
    
    Returns:
    
    a new map representing the current map, but only with the keys in keys
  - containsAll
```
public boolean containsAll(ISet<K> set)
```
    Specified by:
    
    containsAll in interface IMap<K,V>
    
    Returns:
    
    true if this map contains all elements in set
  - containsAll
```
public boolean containsAll(IMap<K,?> map)
```
    Specified by:
    
    containsAll in interface IMap<K,V>
    
    Returns:
    
    true if this map contains all keys in map
  - containsAny
```
public boolean containsAny(ISet<K> set)
```
    Specified by:
    
    containsAny in interface IMap<K,V>
    
    Returns:
    
    true if this map contains any element in set
  - containsAny
```
public boolean containsAny(IMap<K,?> map)
```
    Specified by:
    
    containsAny in interface IMap<K,V>
    
    Returns:
    
    true if this map contains any element in map

Class LinearMap<K,V>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.lacuna.bifurcan.IMap

Methods inherited from interface io.lacuna.bifurcan.ICollection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.function.Function

Field Detail

MAX_CAPACITY

Constructor Detail

LinearMap

LinearMap

LinearMap

LinearMap

Method Detail

from

from

from

from

from

keyHash

keyEquality

put

put

remove

clear

mapValues

get

update

keys

indexOf

nth

size

isLinear

forked

linear

equals

clone

hashCode

toString

split

union

merge

difference

difference

intersection

intersection

containsAll

containsAll

containsAny

containsAny