IntMap

java.lang.Object
- io.lacuna.bifurcan.IntMap<V>

All Implemented Interfaces:

ICollection<IMap<Long,V>,IEntry<Long,V>>, IMap<Long,V>, ISortedMap<Long,V>, Cloneable, Iterable<IEntry<Long,V>>, Function<Long,V>
```
public class IntMap<V>
extends Object
implements ISortedMap<Long,V>, Cloneable
```
A map which has integer keys, which is an combination of Okasaki and Gill's Fast Mergeable Integer Maps with the memory layout suggested by Steindorfer and Vinju used in Map, with which it shares the same broad performance characteristics.
This collection keeps the keys in sorted order, and can thought of as either a map of integers or a sparse vector. It provides slice(Long, Long), floor(Long), and ceil(Long) methods which allow for lookups and filtering on its keys.

Constructor Summary

Constructors
Constructor and Description

IntMap()

Constructors
Constructor and Description
`IntMap()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`IEntry<Long,V>`	`ceil(long key)`
`IEntry<Long,V>`	`ceil(Long key)`
`IntMap<V>`	`clone()`
`Comparator<Long>`	`comparator()`
`boolean`	`contains(long key)`
`boolean`	`contains(Long key)`
`IntMap<V>`	`difference(IMap<Long,?> b)`
`IntMap<V>`	`difference(ISet<Long> keys)`
`boolean`	`equals(IMap<Long,V> o, BiPredicate<V,V> valEquals)`
`boolean`	`equals(Object obj)`
`IEntry<Long,V>`	`floor(long key)`
`IEntry<Long,V>`	`floor(Long key)`
`IntMap<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 <V> IntMap<V>`	`from(Collection<Map.Entry<Number,V>> collection)`
`static <V> IntMap<V>`	`from(IList<IEntry<Number,V>> list)`
`static <V> IntMap<V>`	`from(IMap<Number,V> m)`
`static <V> IntMap<V>`	`from(Map<Number,V> m)`
`Optional<V>`	`get(long key)`
`V`	`get(long key, V defaultValue)`
`V`	`get(Long key, V defaultValue)`
`int`	`hashCode()`
`OptionalLong`	`indexOf(long key)`
`OptionalLong`	`indexOf(Long key)`
`IntMap<V>`	`intersection(IMap<Long,?> b)`
`IntMap<V>`	`intersection(ISet<Long> keys)`
`boolean`	`isLinear()`
`Iterator<IEntry<Long,V>>`	`iterator()`
`BiPredicate<Long,Long>`	`keyEquality()`
`ToLongFunction<Long>`	`keyHash()`
`IntMap<V>`	`linear()` This returns a data structure which is linear, or temporarily mutable.
`<U> IntMap<U>`	`mapValues(BiFunction<Long,V,U> f)`
`IntMap<V>`	`merge(IMap<Long,V> b, BinaryOperator<V> mergeFn)`
`IEntry<Long,V>`	`nth(long idx)`
`IntMap<V>`	`put(long key, V value)`
`IntMap<V>`	`put(Long key, V value)`
`IntMap<V>`	`put(long key, V value, BinaryOperator<V> merge)`
`IntMap<V>`	`put(Long key, V value, BinaryOperator<V> merge)`
`IntMap<V>`	`put(long key, V value, BinaryOperator<V> merge, Object editor)`
`IntMap<V>`	`put(long key, V value, Object editor)`
`IntMap<V>`	`remove(long key)`
`IntMap<V>`	`remove(Long key)`
`IntMap<V>`	`remove(long key, Object editor)`
`long`	`size()`
`IntMap<V>`	`slice(long min, long max)`
`IntMap<V>`	`slice(Long min, Long max)`
`List<IntMap<V>>`	`split(int parts)` Splits the collection into roughly even pieces, for parallel processing.
`String`	`toString()`
`IntMap<V>`	`union(IMap<Long,V> m)`
`IntMap<V>`	`update(long key, UnaryOperator<V> update)`
`IntMap<V>`	`update(Long key, UnaryOperator<V> update)`
`IntMap<V>`	`update(long key, UnaryOperator<V> update, Object editor)`

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

Methods inherited from interface io.lacuna.bifurcan.ISortedMap
first, last

Methods inherited from interface io.lacuna.bifurcan.IMap
apply, containsAll, containsAll, containsAny, containsAny, entries, get, getOrCreate, hashSortedEntries, keys, 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

- Constructor Detail
  - IntMap
```
public IntMap()
```
- Method Detail
  - from
```
public static <V> IntMap<V> from(IMap<Number,V> m)
```
    Parameters:
    
    m - another map
    
    Returns:
    
    a forked copy of the map
  - from
```
public static <V> IntMap<V> from(Map<Number,V> m)
```
    Returns:
    
    a forked copy of m
  - from
```
public static <V> IntMap<V> from(Collection<Map.Entry<Number,V>> collection)
```
    Parameters:
    
    collection - a collection of Map.Entry objects
    
    Returns:
    
    an IntMap representing the entries in the collection
  - from
```
public static <V> IntMap<V> from(IList<IEntry<Number,V>> list)
```
    Parameters:
    
    list - a list of IEntry objects
    
    Returns:
    
    an IntMap representing the entries in the list
  - comparator
```
public Comparator<Long> comparator()
```
    Specified by:
    
    comparator in interface ISortedMap<Long,V>
  - keyHash
```
public ToLongFunction<Long> keyHash()
```
    Specified by:
    
    keyHash in interface IMap<Long,V>
    
    Returns:
    
    the hash function used by the map
  - keyEquality
```
public BiPredicate<Long,Long> keyEquality()
```
    Specified by:
    
    keyEquality in interface IMap<Long,V>
    
    Returns:
    
    the key equality semantics used by the map
  - slice
```
public IntMap<V> slice(long min,
                       long max)
```
    Parameters:
    
    min - the inclusive minimum key value
    
    max - the inclusive maximum key value
    
    Returns:
    
    a map representing all entries within [min, max]
  - slice
```
public IntMap<V> slice(Long min,
                       Long max)
```
    Specified by:
    
    slice in interface ISortedMap<Long,V>
    
    Parameters:
    
    min - the inclusive minimum key value
    
    max - the inclusive maximum key value
    
    Returns:
    
    a map representing all entries within [ min, max]
  - merge
```
public IntMap<V> merge(IMap<Long,V> b,
                       BinaryOperator<V> mergeFn)
```
    Specified by:
    
    merge in interface IMap<Long,V>
    
    Specified by:
    
    merge in interface ISortedMap<Long,V>
    
    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
```
public IntMap<V> difference(ISet<Long> keys)
```
    Specified by:
    
    difference in interface IMap<Long,V>
    
    Specified by:
    
    difference in interface ISortedMap<Long,V>
    
    Returns:
    
    a new map representing the current map, less the keys in keys
  - intersection
```
public IntMap<V> intersection(ISet<Long> keys)
```
    Specified by:
    
    intersection in interface IMap<Long,V>
    
    Specified by:
    
    intersection in interface ISortedMap<Long,V>
    
    Returns:
    
    a new map representing the current map, but only with the keys in keys
  - union
```
public IntMap<V> union(IMap<Long,V> m)
```
    Specified by:
    
    union in interface IMap<Long,V>
    
    Specified by:
    
    union in interface ISortedMap<Long,V>
    
    Returns:
    
    a combined map, with the values from m shadowing those in this amp
  - difference
```
public IntMap<V> difference(IMap<Long,?> b)
```
    Specified by:
    
    difference in interface IMap<Long,V>
    
    Specified by:
    
    difference in interface ISortedMap<Long,V>
    
    Returns:
    
    a new map representing the current map, less the keys in m
  - intersection
```
public IntMap<V> intersection(IMap<Long,?> b)
```
    Specified by:
    
    intersection in interface IMap<Long,V>
    
    Returns:
    
    a new map representing the current map, but only with the keys in m
  - put
```
public IntMap<V> put(long key,
                     V value)
```
    Parameters:
    
    key - a primitive long key
    
    value - a value
    
    Returns:
    
    an updated IntMap with value under key
  - put
```
public IntMap<V> put(long key,
                     V value,
                     Object editor)
```
  - put
```
public IntMap<V> put(long key,
                     V value,
                     BinaryOperator<V> merge)
```
    Parameters:
    
    key - a primitive long key
    
    value - a value
    
    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
  - put
```
public IntMap<V> put(long key,
                     V value,
                     BinaryOperator<V> merge,
                     Object editor)
```
  - put
```
public IntMap<V> put(Long key,
                     V value)
```
    Specified by:
    
    put in interface IMap<Long,V>
    
    Specified by:
    
    put in interface ISortedMap<Long,V>
    
    Returns:
    
    an updated map with value stored under key
  - put
```
public IntMap<V> put(Long key,
                     V value,
                     BinaryOperator<V> merge)
```
    Specified by:
    
    put in interface IMap<Long,V>
    
    Specified by:
    
    put in interface ISortedMap<Long,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 IntMap<V> remove(long key)
```
    Returns:
    
    an updated map that does not contain key
  - remove
```
public IntMap<V> remove(long key,
                        Object editor)
```
  - remove
```
public IntMap<V> remove(Long key)
```
    Specified by:
    
    remove in interface IMap<Long,V>
    
    Specified by:
    
    remove in interface ISortedMap<Long,V>
    
    Returns:
    
    an updated map that does not contain key
  - mapValues
```
public <U> IntMap<U> mapValues(BiFunction<Long,V,U> f)
```
    Specified by:
    
    mapValues in interface IMap<Long,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 Optional<V> get(long key)
```
  - get
```
public V get(long key,
             V defaultValue)
```
  - get
```
public V get(Long key,
             V defaultValue)
```
    Specified by:
    
    get in interface IMap<Long,V>
    
    Returns:
    
    the value under key, or defaultValue if there is no such key
  - update
```
public IntMap<V> update(Long key,
                        UnaryOperator<V> update)
```
    Specified by:
    
    update in interface IMap<Long,V>
    
    Specified by:
    
    update in interface ISortedMap<Long,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.
  - update
```
public IntMap<V> update(long key,
                        UnaryOperator<V> update)
```
  - update
```
public IntMap<V> update(long key,
                        UnaryOperator<V> update,
                        Object editor)
```
  - contains
```
public boolean contains(long key)
```
  - contains
```
public boolean contains(Long key)
```
    Specified by:
    
    contains in interface IMap<Long,V>
    
    Returns:
    
    true if key is in the map, false otherwise
  - indexOf
```
public OptionalLong indexOf(Long key)
```
    Specified by:
    
    indexOf in interface IMap<Long,V>
    
    Returns:
    
    the index of key within the collection, if it's present
  - indexOf
```
public OptionalLong indexOf(long key)
```
  - nth
```
public IEntry<Long,V> nth(long idx)
```
    Specified by:
    
    nth in interface ICollection<IMap<Long,V>,IEntry<Long,V>>
    
    Returns:
    
    the element at idx
  - iterator
```
public Iterator<IEntry<Long,V>> iterator()
```
    Specified by:
    
    iterator in interface IMap<Long,V>
    
    Specified by:
    
    iterator in interface Iterable<IEntry<Long,V>>
    
    Returns:
    
    an iterator over all entries in the map
  - floor
```
public IEntry<Long,V> floor(long key)
```
    Returns:
    
    the entry whose key is either equal to key, or just below it. If key is less than the minimum value in the map, returns null.
  - floor
```
public IEntry<Long,V> floor(Long key)
```
    Specified by:
    
    floor in interface ISortedMap<Long,V>
    
    Returns:
    
    the entry whose key is either equal to key, or just below it. If key is less than the minimum value in the map, returns null.
  - ceil
```
public IEntry<Long,V> ceil(long key)
```
    Returns:
    
    the entry whose key is either equal to key, or just above it. If key is greater than the maximum value in the map, returns null.
  - ceil
```
public IEntry<Long,V> ceil(Long key)
```
    Specified by:
    
    ceil in interface ISortedMap<Long,V>
    
    Returns:
    
    the entry whose key is either equal to key, or just above it. If key is greater than the maximum value in the map, returns null.
  - size
```
public long size()
```
    Specified by:
    
    size in interface ICollection<IMap<Long,V>,IEntry<Long,V>>
    
    Returns:
    
    the number of elements in the collection
  - isLinear
```
public boolean isLinear()
```
    Specified by:
    
    isLinear in interface ICollection<IMap<Long,V>,IEntry<Long,V>>
    
    Specified by:
    
    isLinear in interface IMap<Long,V>
    
    Returns:
    
    true, if the collection is linear
  - forked
```
public IntMap<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<Long,V>,IEntry<Long,V>>
    
    Specified by:
    
    forked in interface IMap<Long,V>
    
    Specified by:
    
    forked in interface ISortedMap<Long,V>
    
    Returns:
    
    a forked form of the data structure
  - linear
```
public IntMap<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<Long,V>,IEntry<Long,V>>
    
    Specified by:
    
    linear in interface IMap<Long,V>
    
    Specified by:
    
    linear in interface ISortedMap<Long,V>
    
    Returns:
    
    a linear form of this data structure
  - split
```
public List<IntMap<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<Long,V>,IEntry<Long,V>>
    
    Specified by:
    
    split in interface IMap<Long,V>
    
    Parameters:
    
    parts - the target number of pieces
    
    Returns:
    
    a list containing subsets of the collection.
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(IMap<Long,V> o,
                      BiPredicate<V,V> valEquals)
```
    Specified by:
    
    equals in interface IMap<Long,V>
    
    Parameters:
    
    o - another map
    
    valEquals - a predicate which checks value equalities
    
    Returns:
    
    true, if the maps are equivalent
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - clone
```
public IntMap<V> clone()
```
    Specified by:
    
    clone in interface ICollection<IMap<Long,V>,IEntry<Long,V>>
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    a cloned copy of the collection

Class IntMap<V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.lacuna.bifurcan.ISortedMap

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

Constructor Detail

IntMap

Method Detail

from

from

from

from

comparator

keyHash

keyEquality

slice

slice

merge

difference

intersection

union

difference

intersection

put

put

put

put

put

put

remove

remove

remove

mapValues

get

get

get

update

update

update

contains

contains

indexOf

indexOf

nth

iterator

floor

floor

ceil

ceil

size

isLinear

forked

linear

split

hashCode

equals

equals

toString

clone