ImmutableSortedMap

Type Parameters:

K - the type of map keys. The map is invariant on its key type, as it can accept key as a parameter (of containsKey for example) and return it in keys set.

V - the type of map values. The map is covariant on its value type.

All Superinterfaces:

ImmutableMap<K,V>

All Known Subinterfaces:

ImmutableNavigableMap<K,V>
```
public ImmutableSortedMap<K,V>
extends ImmutableMap<K,V>
```
An interface that mimics the original SortedMap but without exposing modification functions to Kotlin source codes.
Modifications are strictly forbidden after the map is created.

See Also:

SortedMap

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`java.util.Comparator<? super K>`	`comparator()` Returns the comparator used to order the keys in this map, or `null` if this map uses the natural ordering of its keys.
`K`	`firstKey()` Returns the first (lowest) key currently in this map.
`java.util.Set<java.util.Map.Entry>`	`getEntries()` Returns a Set view of the mappings contained in this map. The set's iterator returns the entries in ascending key order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation, or through the `setValue` operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.
`java.util.Set<K>`	`getKeys()` Returns a Set view of the keys contained in this map. The set's iterator returns the keys in ascending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll`, and `clear` operations. It does not support the `add` or `addAll` operations.
`java.util.Collection<V>`	`getValues()` Returns a Collection view of the values contained in this map. The collection's iterator returns the values in ascending order of the corresponding keys. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Collection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.
`ImmutableSortedMap<K,V>`	`head(K toKey)` Returns a view of the portion of this map whose keys are strictly less than `toKey`. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.
`K`	`lastKey()` Returns the last (highest) key currently in this map.
`ImmutableSortedMap<K,V>`	`sub(K fromKey, K toKey)` Returns a view of the portion of this map whose keys range from `fromKey`, inclusive, to `toKey`, exclusive. (If `fromKey` and `toKey` are equal, the returned map is empty.) The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.
`ImmutableSortedMap<K,V>`	`tail(K fromKey)` Returns a view of the portion of this map whose keys are greater than or equal to `fromKey`. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.

- Method Detail
  - comparator
```
java.util.Comparator<? super K> comparator()
```
    Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.
    
    Returns:
    
    the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys
  - sub
```
ImmutableSortedMap<K,V> sub(K fromKey,
                            K toKey)
```
    Returns a view of the portion of this map whose keys range from fromKey, inclusive, to toKey, exclusive. (If fromKey and toKey are equal, the returned map is empty.) The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.
    The returned map will throw an IllegalArgumentException on an attempt to insert a key outside its range.
    
    Parameters:
    
    fromKey - low endpoint (inclusive) of the keys in the returned map
    
    toKey - high endpoint (exclusive) of the keys in the returned map
    
    Returns:
    
    a view of the portion of this map whose keys range from fromKey, inclusive, to toKey, exclusive
    
    Throws:
    
    - if fromKey and toKey cannot be compared to one another using this map's comparator (or, if the map has no comparator, using natural ordering). Implementations may, but are not required to, throw this exception if fromKey or toKey cannot be compared to keys currently in the map.
    
    - if fromKey or toKey is null and this map does not permit null keys
    
    - if fromKey is greater than toKey; or if this map itself has a restricted range, and fromKey or toKey lies outside the bounds of the range
  - head
```
ImmutableSortedMap<K,V> head(K toKey)
```
    Returns a view of the portion of this map whose keys are strictly less than toKey. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.
    The returned map will throw an IllegalArgumentException on an attempt to insert a key outside its range.
    
    Parameters:
    
    toKey - high endpoint (exclusive) of the keys in the returned map
    
    Returns:
    
    a view of the portion of this map whose keys are strictly less than toKey
    
    Throws:
    
    - if toKey is not compatible with this map's comparator (or, if the map has no comparator, if toKey does not implement Comparable). Implementations may, but are not required to, throw this exception if toKey cannot be compared to keys currently in the map.
    
    - if toKey is null and this map does not permit null keys
    
    - if this map itself has a restricted range, and toKey lies outside the bounds of the range
  - tail
```
ImmutableSortedMap<K,V> tail(K fromKey)
```
    Returns a view of the portion of this map whose keys are greater than or equal to fromKey. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.
    The returned map will throw an IllegalArgumentException on an attempt to insert a key outside its range.
    
    Parameters:
    
    fromKey - low endpoint (inclusive) of the keys in the returned map
    
    Returns:
    
    a view of the portion of this map whose keys are greater than or equal to fromKey
    
    Throws:
    
    - if fromKey is not compatible with this map's comparator (or, if the map has no comparator, if fromKey does not implement Comparable). Implementations may, but are not required to, throw this exception if fromKey cannot be compared to keys currently in the map.
    
    - if fromKey is null and this map does not permit null keys
    
    - if this map itself has a restricted range, and fromKey lies outside the bounds of the range
  - firstKey
```
K firstKey()
```
    Returns the first (lowest) key currently in this map.
    
    Returns:
    
    the first (lowest) key currently in this map
    
    Throws:
    
    - if this map is empty
  - lastKey
```
K lastKey()
```
    Returns the last (highest) key currently in this map.
    
    Returns:
    
    the last (highest) key currently in this map
    
    Throws:
    
    - if this map is empty
  - getKeys
```
java.util.Set<K> getKeys()
```
    Returns a Set view of the keys contained in this map. The set's iterator returns the keys in ascending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.
    
    Returns:
    
    a set view of the keys contained in this map, sorted in ascending order
  - getValues
```
java.util.Collection<V> getValues()
```
    Returns a Collection view of the values contained in this map. The collection's iterator returns the values in ascending order of the corresponding keys. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Collection.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.
    
    Returns:
    
    a collection view of the values contained in this map, sorted in ascending key order
  - getEntries
```
java.util.Set<java.util.Map.Entry> getEntries()
```
    Returns a Set view of the mappings contained in this map. The set's iterator returns the entries in ascending key order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation, or through the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.
    
    Returns:
    
    a set view of the mappings contained in this map, sorted in ascending key order

Interface ImmutableSortedMap<K,V>

Method Summary

Method Detail

comparator

sub

head

tail

firstKey

lastKey

getKeys

getValues

getEntries