org.apache.commons.collections4.trie

## Class UnmodifiableTrie<K,V>

- java.lang.Object
- - org.apache.commons.collections4.trie.UnmodifiableTrie<K,V>

- Type Parameters:
    `K` - the type of the keys in this map
    `V` - the type of the values in this map
  All Implemented Interfaces:
    Serializable, Map<K,V>, SortedMap<K,V>, Get<K,V>, IterableGet<K,V>, IterableMap<K,V>, IterableSortedMap<K,V>, OrderedMap<K,V>, Put<K,V>, Trie<K,V>, Unmodifiable

      public class UnmodifiableTrie<K,V>
      extends Object
      implements Trie<K,V>, Serializable, Unmodifiable

  An unmodifiable `Trie`.
  Since:
    4.0
  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface java.util.Map

      `Map.Entry<K,V>`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `UnmodifiableTrie(Trie<K,? extends V> trie)` Constructor that wraps (not copies).

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clear()`
    `Comparator<? super K>` | `comparator()`
    `boolean` | `containsKey(Object key)`
    `boolean` | `containsValue(Object value)`
    `Set<Map.Entry<K,V>>` | `entrySet()`
    `boolean` | `equals(Object obj)`
    `K` | `firstKey()` Gets the first key currently in this map.
    `V` | `get(Object key)`
    `int` | `hashCode()`
    `SortedMap<K,V>` | `headMap(K toKey)`
    `boolean` | `isEmpty()`
    `Set<K>` | `keySet()`
    `K` | `lastKey()` Gets the last key currently in this map.
    `OrderedMapIterator<K,V>` | `mapIterator()` Obtains an `OrderedMapIterator` over the map.
    `K` | `nextKey(K key)` Gets the next key after the one specified.
    `SortedMap<K,V>` | `prefixMap(K key)` Returns a view of this `Trie` of all elements that are prefixed by the given key.
    `K` | `previousKey(K key)` Gets the previous key before the one specified.
    `V` | `put(K key, V value)` Note that the return type is Object, rather than V as in the Map interface.
    `void` | `putAll(Map<? extends K,? extends V> m)`
    `V` | `remove(Object key)`
    `int` | `size()`
    `SortedMap<K,V>` | `subMap(K fromKey, K toKey)`
    `SortedMap<K,V>` | `tailMap(K fromKey)`
    `String` | `toString()`
    `static <K,V> Trie<K,V>` | `unmodifiableTrie(Trie<K,? extends V> trie)` Factory method to create a unmodifiable trie.
    `Collection<V>` | `values()`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface java.util.Map

      `compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll`

- - ### Constructor Detail

    - #### UnmodifiableTrie

          public UnmodifiableTrie(Trie<K,? extends V> trie)

      Constructor that wraps (not copies).
      Parameters:
        `trie` - the trie to decorate, must not be null
      Throws:
        `NullPointerException` - if trie is null

  - ### Method Detail

    - #### unmodifiableTrie

          public static <K,V> Trie<K,V> unmodifiableTrie(Trie<K,? extends V> trie)

      Factory method to create a unmodifiable trie.
      Type Parameters:
        `K` - the key type
        `V` - the value type
      Parameters:
        `trie` - the trie to decorate, must not be null
      Returns:
        a new unmodifiable trie
      Throws:
        `NullPointerException` - if trie is null

    - #### entrySet

          public Set<Map.Entry<K,V>> entrySet()

      Specified by:
        `entrySet` in interface `Map<K,V>`
      Specified by:
        `entrySet` in interface `SortedMap<K,V>`
      Specified by:
        `entrySet` in interface `Get<K,V>`
      Returns:
        a set view of the mappings contained in this map
      See Also:
        `Map.entrySet()`

    - #### keySet

          public Set<K> keySet()

      Specified by:
        `keySet` in interface `Map<K,V>`
      Specified by:
        `keySet` in interface `SortedMap<K,V>`
      Specified by:
        `keySet` in interface `Get<K,V>`
      Returns:
        a set view of the keys contained in this map
      See Also:
        `Map.keySet()`

    - #### values

          public Collection<V> values()

      Specified by:
        `values` in interface `Map<K,V>`
      Specified by:
        `values` in interface `SortedMap<K,V>`
      Specified by:
        `values` in interface `Get<K,V>`
      Returns:
        a collection view of the values contained in this map
      See Also:
        `Map.values()`

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `Map<K,V>`
      Specified by:
        `clear` in interface `Put<K,V>`
      See Also:
        `Map.clear()`

    - #### containsKey

          public boolean containsKey(Object key)

      Specified by:
        `containsKey` in interface `Map<K,V>`
      Specified by:
        `containsKey` in interface `Get<K,V>`
      Parameters:
        `key` - key whose presence in this map is to be tested
      Returns:
        `true` if this map contains a mapping for the specified key
      See Also:
        `Map.containsKey(Object)`

    - #### containsValue

          public boolean containsValue(Object value)

      Specified by:
        `containsValue` in interface `Map<K,V>`
      Specified by:
        `containsValue` in interface `Get<K,V>`
      Parameters:
        `value` - value whose presence in this map is to be tested
      Returns:
        `true` if this map maps one or more keys to the specified value
      See Also:
        `Map.containsValue(Object)`

    - #### get

          public V get(Object key)

      Specified by:
        `get` in interface `Map<K,V>`
      Specified by:
        `get` in interface `Get<K,V>`
      Parameters:
        `key` - the key whose associated value is to be returned
      Returns:
        the value to which the specified key is mapped, or `null` if this map contains no mapping for the key
      See Also:
        `Map.get(Object)`

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `Map<K,V>`
      Specified by:
        `isEmpty` in interface `Get<K,V>`
      Returns:
        `true` if this map contains no key-value mappings
      See Also:
        `Map.isEmpty()`

    - #### put

          public V put(K key,
                       V value)

      Description copied from interface: `Put`
      Note that the return type is Object, rather than V as in the Map interface. See the class Javadoc for further info.
      Specified by:
        `put` in interface `Map<K,V>`
      Specified by:
        `put` in interface `Put<K,V>`
      Parameters:
        `key` - key with which the specified value is to be associated
        `value` - value to be associated with the specified key
      Returns:
        the previous value associated with `key`, or `null` if there was no mapping for `key`. (A `null` return can also indicate that the map previously associated `null` with `key`, if the implementation supports `null` values.)
      See Also:
        `Map.put(Object, Object)`

    - #### putAll

          public void putAll(Map<? extends K,? extends V> m)

      Specified by:
        `putAll` in interface `Map<K,V>`
      Specified by:
        `putAll` in interface `Put<K,V>`
      Parameters:
        `m` - mappings to be stored in this map
      See Also:
        `Map.putAll(Map)`

    - #### remove

          public V remove(Object key)

      Specified by:
        `remove` in interface `Map<K,V>`
      Specified by:
        `remove` in interface `Get<K,V>`
      Parameters:
        `key` - key whose mapping is to be removed from the map
      Returns:
        the previous value associated with `key`, or `null` if there was no mapping for `key`.
      See Also:
        `Map.remove(Object)`

    - #### size

          public int size()

      Specified by:
        `size` in interface `Map<K,V>`
      Specified by:
        `size` in interface `Get<K,V>`
      Returns:
        the number of key-value mappings in this map
      See Also:
        `Map.size()`

    - #### firstKey

          public K firstKey()

      Description copied from interface: `OrderedMap`
      Gets the first key currently in this map.
      Specified by:
        `firstKey` in interface `SortedMap<K,V>`
      Specified by:
        `firstKey` in interface `OrderedMap<K,V>`
      Returns:
        the first key currently in this map

    - #### headMap

          public SortedMap<K,V> headMap(K toKey)

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

    - #### lastKey

          public K lastKey()

      Description copied from interface: `OrderedMap`
      Gets the last key currently in this map.
      Specified by:
        `lastKey` in interface `SortedMap<K,V>`
      Specified by:
        `lastKey` in interface `OrderedMap<K,V>`
      Returns:
        the last key currently in this map

    - #### subMap

          public SortedMap<K,V> subMap(K fromKey,
                                       K toKey)

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

    - #### tailMap

          public SortedMap<K,V> tailMap(K fromKey)

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

    - #### prefixMap

          public SortedMap<K,V> prefixMap(K key)

      Description copied from interface: `Trie`
      Returns a view of this `Trie` of all elements that are prefixed by the given key.

      In a `Trie` with fixed size keys, this is essentially a `Map.get(Object)` operation.

      For example, if the `Trie` contains 'Anna', 'Anael', 'Analu', 'Andreas', 'Andrea', 'Andres', and 'Anatole', then a lookup of 'And' would return 'Andreas', 'Andrea', and 'Andres'.

      Specified by:
        `prefixMap` in interface `Trie<K,V>`
      Parameters:
        `key` - the key used in the search
      Returns:
        a `SortedMap` view of this `Trie` with all elements whose key is prefixed by the search key

    - #### comparator

          public Comparator<? super K> comparator()

      Specified by:
        `comparator` in interface `SortedMap<K,V>`

    - #### mapIterator

          public OrderedMapIterator<K,V> mapIterator()

      Description copied from interface: `OrderedMap`
      Obtains an `OrderedMapIterator` over the map.

      A ordered map iterator is an efficient way of iterating over maps in both directions.

      Specified by:
        `mapIterator` in interface `IterableGet<K,V>`
      Specified by:
        `mapIterator` in interface `OrderedMap<K,V>`
      Returns:
        a map iterator

    - #### nextKey

          public K nextKey(K key)

      Description copied from interface: `OrderedMap`
      Gets the next key after the one specified.
      Specified by:
        `nextKey` in interface `OrderedMap<K,V>`
      Parameters:
        `key` - the key to search for next from
      Returns:
        the next key, null if no match or at end

    - #### previousKey

          public K previousKey(K key)

      Description copied from interface: `OrderedMap`
      Gets the previous key before the one specified.
      Specified by:
        `previousKey` in interface `OrderedMap<K,V>`
      Parameters:
        `key` - the key to search for previous from
      Returns:
        the previous key, null if no match or at start

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in interface `Map<K,V>`
      Overrides:
        `hashCode` in class `Object`

    - #### equals

          public boolean equals(Object obj)

      Specified by:
        `equals` in interface `Map<K,V>`
      Overrides:
        `equals` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

Copyright © 2001–2019 The Apache Software Foundation. All rights reserved.