## com.google.common.collect
Class ForwardingNavigableMap<K,V>

    java.lang.Object
      com.google.common.collect.ForwardingObject
          com.google.common.collect.ForwardingMap<K,V>
              com.google.common.collect.ForwardingSortedMap<K,V>
                  com.google.common.collect.ForwardingNavigableMap<K,V>

All Implemented Interfaces:
  Map<K,V>, NavigableMap<K,V>, SortedMap<K,V>

    @Beta
    public abstract class ForwardingNavigableMap<K,V>

extends ForwardingSortedMap<K,V>
implements NavigableMap<K,V>

A navigable map which forwards all its method calls to another navigable map. Subclasses should override one or more methods to modify the behavior of the backing map as desired per the decorator pattern.

Warning: The methods of `ForwardingNavigableMap` forward indiscriminately to the methods of the delegate. For example, overriding `ForwardingMap.put(K, V)` alone will not change the behavior of `ForwardingMap.putAll(java.util.Map<? extends K, ? extends V>)`, which can lead to unexpected behavior. In this case, you should override `putAll` as well, either providing your own implementation, or delegating to the provided `standardPutAll` method.

Each of the `standard` methods uses the map's comparator (or the natural ordering of the elements, if there is no comparator) to test element equality. As a result, if the comparator is not consistent with equals, some of the standard implementations may violate the `Map` contract.

The `standard` methods and the collection views they return are not guaranteed to be thread-safe, even when all of the methods that they depend on are thread-safe.

Since:
  12.0
Author:
  Louis Wasserman

Nested Class Summary
`protected class` `ForwardingNavigableMap.StandardDescendingMap` A sensible implementation of `NavigableMap.descendingMap()` in terms of the methods of this `NavigableMap`.
`protected class` `ForwardingNavigableMap.StandardNavigableKeySet` A sensible implementation of `NavigableMap.navigableKeySet()` in terms of the methods of this `NavigableMap`.

Nested classes/interfaces inherited from class com.google.common.collect.ForwardingMap
`ForwardingMap.StandardEntrySet, ForwardingMap.StandardKeySet, ForwardingMap.StandardValues`

Nested classes/interfaces inherited from interface java.util.Map
`Map.Entry<K,V>`

Constructor Summary
`protected` `ForwardingNavigableMap()` Constructor for use by subclasses.

Method Summary
`Map.Entry<K,V>` `ceilingEntry(K key)`
`K` `ceilingKey(K key)`
`protected abstract NavigableMap<K,V>` `delegate()` Returns the backing delegate instance that methods are forwarded to.
`NavigableSet<K>` `descendingKeySet()`
`NavigableMap<K,V>` `descendingMap()`
`Map.Entry<K,V>` `firstEntry()`
`Map.Entry<K,V>` `floorEntry(K key)`
`K` `floorKey(K key)`
`NavigableMap<K,V>` `headMap(K toKey, boolean inclusive)`
`Map.Entry<K,V>` `higherEntry(K key)`
`K` `higherKey(K key)`
`Map.Entry<K,V>` `lastEntry()`
`Map.Entry<K,V>` `lowerEntry(K key)`
`K` `lowerKey(K key)`
`NavigableSet<K>` `navigableKeySet()`
`Map.Entry<K,V>` `pollFirstEntry()`
`Map.Entry<K,V>` `pollLastEntry()`
`protected Map.Entry<K,V>` `standardCeilingEntry(K key)` A sensible definition of `ceilingEntry(K)` in terms of the `firstEntry()` of `tailMap(Object, boolean)`.
`protected K` `standardCeilingKey(K key)` A sensible definition of `ceilingKey(K)` in terms of `ceilingEntry`.
`protected NavigableSet<K>` `standardDescendingKeySet()` A sensible definition of `descendingKeySet()` as the `navigableKeySet` of `descendingMap()`.
`protected Map.Entry<K,V>` `standardFirstEntry()` A sensible definition of `firstEntry()` in terms of the `iterator()` of `ForwardingMap.entrySet()`.
`protected K` `standardFirstKey()` A sensible definition of `ForwardingSortedMap.firstKey()` in terms of `firstEntry`.
`protected Map.Entry<K,V>` `standardFloorEntry(K key)` A sensible definition of `floorEntry(K)` in terms of the `lastEntry()` of `headMap(Object, boolean)`.
`protected K` `standardFloorKey(K key)` A sensible definition of `floorKey(K)` in terms of `floorEntry`.
`protected SortedMap<K,V>` `standardHeadMap(K toKey)` A sensible definition of `ForwardingSortedMap.headMap(Object)` in terms of `headMap(Object, boolean)`.
`protected Map.Entry<K,V>` `standardHigherEntry(K key)` A sensible definition of `higherEntry(K)` in terms of the `firstEntry()` of `tailMap(Object, boolean)`.
`protected K` `standardHigherKey(K key)` A sensible definition of `higherKey(K)` in terms of `higherEntry`.
`protected Map.Entry<K,V>` `standardLastEntry()` A sensible definition of `lastEntry()` in terms of the `iterator()` of the `ForwardingMap.entrySet()` of `descendingMap()`.
`protected K` `standardLastKey()` A sensible definition of `ForwardingSortedMap.lastKey()` in terms of `lastEntry`.
`protected Map.Entry<K,V>` `standardLowerEntry(K key)` A sensible definition of `lowerEntry(K)` in terms of the `lastEntry()` of `headMap(Object, boolean)`.
`protected K` `standardLowerKey(K key)` A sensible definition of `lowerKey(K)` in terms of `lowerEntry`.
`protected Map.Entry<K,V>` `standardPollFirstEntry()` A sensible definition of `pollFirstEntry()` in terms of the `iterator` of `entrySet`.
`protected Map.Entry<K,V>` `standardPollLastEntry()` A sensible definition of `pollFirstEntry()` in terms of the `iterator` of the `entrySet` of `descendingMap`.
`protected SortedMap<K,V>` `standardSubMap(K fromKey, K toKey)` A sensible definition of `ForwardingSortedMap.subMap(Object, Object)` in terms of `subMap(Object, boolean, Object, boolean)`.
`protected SortedMap<K,V>` `standardTailMap(K fromKey)` A sensible definition of `ForwardingSortedMap.tailMap(Object)` in terms of `tailMap(Object, boolean)`.
`NavigableMap<K,V>` `subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)`
`NavigableMap<K,V>` `tailMap(K fromKey, boolean inclusive)`

Methods inherited from class com.google.common.collect.ForwardingSortedMap
`comparator, firstKey, headMap, lastKey, standardContainsKey, standardRemove, subMap, tailMap`

Methods inherited from class com.google.common.collect.ForwardingMap
`clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, standardClear, standardContainsValue, standardEquals, standardHashCode, standardIsEmpty, standardPutAll, standardToString, values`

Methods inherited from class com.google.common.collect.ForwardingObject
`toString`

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

Methods inherited from interface java.util.NavigableMap
`headMap, subMap, tailMap`

Methods inherited from interface java.util.SortedMap
`comparator, entrySet, firstKey, keySet, lastKey, values`

Methods inherited from interface java.util.Map
`clear, containsKey, containsValue, equals, get, hashCode, isEmpty, put, putAll, remove, size`

Constructor Detail

### ForwardingNavigableMap

    protected ForwardingNavigableMap()

  Constructor for use by subclasses.

Method Detail

### delegate

    protected abstract NavigableMap<K,V> delegate()

  Description copied from class: `ForwardingObject`
  Returns the backing delegate instance that methods are forwarded to. Abstract subclasses generally override this method with an abstract method that has a more specific return type, such as `ForwardingSet.delegate()`. Concrete subclasses override this method to supply the instance being decorated.

  Specified by:
    `delegate` in class `ForwardingSortedMap<K,V>`

### lowerEntry

    public Map.Entry<K,V> lowerEntry(K key)

  Specified by:
    `lowerEntry` in interface `NavigableMap<K,V>`

### standardLowerEntry

    protected Map.Entry<K,V> standardLowerEntry(K key)

  A sensible definition of `lowerEntry(K)` in terms of the `lastEntry()` of `headMap(Object, boolean)`. If you override `headMap`, you may wish to override `lowerEntry` to forward to this implementation.

### lowerKey

    public K lowerKey(K key)

  Specified by:
    `lowerKey` in interface `NavigableMap<K,V>`

### standardLowerKey

    protected K standardLowerKey(K key)

  A sensible definition of `lowerKey(K)` in terms of `lowerEntry`. If you override `lowerEntry(K)`, you may wish to override `lowerKey` to forward to this implementation.

### floorEntry

    public Map.Entry<K,V> floorEntry(K key)

  Specified by:
    `floorEntry` in interface `NavigableMap<K,V>`

### standardFloorEntry

    protected Map.Entry<K,V> standardFloorEntry(K key)

  A sensible definition of `floorEntry(K)` in terms of the `lastEntry()` of `headMap(Object, boolean)`. If you override `headMap`, you may wish to override `floorEntry` to forward to this implementation.

### floorKey

    public K floorKey(K key)

  Specified by:
    `floorKey` in interface `NavigableMap<K,V>`

### standardFloorKey

    protected K standardFloorKey(K key)

  A sensible definition of `floorKey(K)` in terms of `floorEntry`. If you override `floorEntry`, you may wish to override `floorKey` to forward to this implementation.

### ceilingEntry

    public Map.Entry<K,V> ceilingEntry(K key)

  Specified by:
    `ceilingEntry` in interface `NavigableMap<K,V>`

### standardCeilingEntry

    protected Map.Entry<K,V> standardCeilingEntry(K key)

  A sensible definition of `ceilingEntry(K)` in terms of the `firstEntry()` of `tailMap(Object, boolean)`. If you override `tailMap`, you may wish to override `ceilingEntry` to forward to this implementation.

### ceilingKey

    public K ceilingKey(K key)

  Specified by:
    `ceilingKey` in interface `NavigableMap<K,V>`

### standardCeilingKey

    protected K standardCeilingKey(K key)

  A sensible definition of `ceilingKey(K)` in terms of `ceilingEntry`. If you override `ceilingEntry`, you may wish to override `ceilingKey` to forward to this implementation.

### higherEntry

    public Map.Entry<K,V> higherEntry(K key)

  Specified by:
    `higherEntry` in interface `NavigableMap<K,V>`

### standardHigherEntry

    protected Map.Entry<K,V> standardHigherEntry(K key)

  A sensible definition of `higherEntry(K)` in terms of the `firstEntry()` of `tailMap(Object, boolean)`. If you override `tailMap`, you may wish to override `higherEntry` to forward to this implementation.

### higherKey

    public K higherKey(K key)

  Specified by:
    `higherKey` in interface `NavigableMap<K,V>`

### standardHigherKey

    protected K standardHigherKey(K key)

  A sensible definition of `higherKey(K)` in terms of `higherEntry`. If you override `higherEntry`, you may wish to override `higherKey` to forward to this implementation.

### firstEntry

    public Map.Entry<K,V> firstEntry()

  Specified by:
    `firstEntry` in interface `NavigableMap<K,V>`

### standardFirstEntry

    protected Map.Entry<K,V> standardFirstEntry()

  A sensible definition of `firstEntry()` in terms of the `iterator()` of `ForwardingMap.entrySet()`. If you override `entrySet`, you may wish to override `firstEntry` to forward to this implementation.

### standardFirstKey

    protected K standardFirstKey()

  A sensible definition of `ForwardingSortedMap.firstKey()` in terms of `firstEntry`. If you override `firstEntry`, you may wish to override `firstKey` to forward to this implementation.

### lastEntry

    public Map.Entry<K,V> lastEntry()

  Specified by:
    `lastEntry` in interface `NavigableMap<K,V>`

### standardLastEntry

    protected Map.Entry<K,V> standardLastEntry()

  A sensible definition of `lastEntry()` in terms of the `iterator()` of the `ForwardingMap.entrySet()` of `descendingMap()`. If you override `descendingMap`, you may wish to override `lastEntry` to forward to this implementation.

### standardLastKey

    protected K standardLastKey()

  A sensible definition of `ForwardingSortedMap.lastKey()` in terms of `lastEntry`. If you override `lastEntry`, you may wish to override `lastKey` to forward to this implementation.

### pollFirstEntry

    public Map.Entry<K,V> pollFirstEntry()

  Specified by:
    `pollFirstEntry` in interface `NavigableMap<K,V>`

### standardPollFirstEntry

    protected Map.Entry<K,V> standardPollFirstEntry()

  A sensible definition of `pollFirstEntry()` in terms of the `iterator` of `entrySet`. If you override `entrySet`, you may wish to override `pollFirstEntry` to forward to this implementation.

### pollLastEntry

    public Map.Entry<K,V> pollLastEntry()

  Specified by:
    `pollLastEntry` in interface `NavigableMap<K,V>`

### standardPollLastEntry

    protected Map.Entry<K,V> standardPollLastEntry()

  A sensible definition of `pollFirstEntry()` in terms of the `iterator` of the `entrySet` of `descendingMap`. If you override `descendingMap`, you may wish to override `pollFirstEntry` to forward to this implementation.

### descendingMap

    public NavigableMap<K,V> descendingMap()

  Specified by:
    `descendingMap` in interface `NavigableMap<K,V>`

### navigableKeySet

    public NavigableSet<K> navigableKeySet()

  Specified by:
    `navigableKeySet` in interface `NavigableMap<K,V>`

### descendingKeySet

    public NavigableSet<K> descendingKeySet()

  Specified by:
    `descendingKeySet` in interface `NavigableMap<K,V>`

### standardDescendingKeySet

    protected NavigableSet<K> standardDescendingKeySet()

  A sensible definition of `descendingKeySet()` as the `navigableKeySet` of `descendingMap()`. (The `ForwardingNavigableMap.StandardDescendingMap` implementation implements `navigableKeySet` on its own, so as not to cause an infinite loop.) If you override `descendingMap`, you may wish to override `descendingKeySet` to forward to this implementation.

### standardSubMap

    protected SortedMap<K,V> standardSubMap(K fromKey,
                                            K toKey)

  A sensible definition of `ForwardingSortedMap.subMap(Object, Object)` in terms of `subMap(Object, boolean, Object, boolean)`. If you override `subMap(K, boolean, K, boolean)`, you may wish to override `subMap` to forward to this implementation.

  Overrides:
    `standardSubMap` in class `ForwardingSortedMap<K,V>`

### subMap

    public NavigableMap<K,V> subMap(K fromKey,
                                    boolean fromInclusive,
                                    K toKey,
                                    boolean toInclusive)

  Specified by:
    `subMap` in interface `NavigableMap<K,V>`

### headMap

    public NavigableMap<K,V> headMap(K toKey,
                                     boolean inclusive)

  Specified by:
    `headMap` in interface `NavigableMap<K,V>`

### tailMap

    public NavigableMap<K,V> tailMap(K fromKey,
                                     boolean inclusive)

  Specified by:
    `tailMap` in interface `NavigableMap<K,V>`

### standardHeadMap

    protected SortedMap<K,V> standardHeadMap(K toKey)

  A sensible definition of `ForwardingSortedMap.headMap(Object)` in terms of `headMap(Object, boolean)`. If you override `headMap(K, boolean)`, you may wish to override `headMap` to forward to this implementation.

### standardTailMap

    protected SortedMap<K,V> standardTailMap(K fromKey)

  A sensible definition of `ForwardingSortedMap.tailMap(Object)` in terms of `tailMap(Object, boolean)`. If you override `tailMap(K, boolean)`, you may wish to override `tailMap` to forward to this implementation.

Copyright © 2010-2012. All Rights Reserved.