org.springframework.util

## Class LinkedCaseInsensitiveMap<V>

- java.lang.Object
- - java.util.AbstractMap<K,V>
  - - java.util.HashMap<K,V>
    - - java.util.LinkedHashMap<String,V>
      - - org.springframework.util.LinkedCaseInsensitiveMap<V>

- All Implemented Interfaces:
    Serializable, Cloneable, Map<String,V>

      public class LinkedCaseInsensitiveMap<V>
      extends LinkedHashMap<String,V>

  `LinkedHashMap` variant that stores String keys in a case-insensitive manner, for example for key-based access in a results table.

  Preserves the original order as well as the original casing of keys, while allowing for contains, get and remove calls with any case of key.

  Does not support `null` keys.

  Since:
    3.0
  Author:
    Juergen Hoeller
  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class java.util.AbstractMap

      `AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `LinkedCaseInsensitiveMap()` Create a new LinkedCaseInsensitiveMap for the default Locale.
    `LinkedCaseInsensitiveMap(int initialCapacity)` Create a new LinkedCaseInsensitiveMap that wraps a `LinkedHashMap` with the given initial capacity and stores lower-case keys according to the default Locale.
    `LinkedCaseInsensitiveMap(int initialCapacity, Locale locale)` Create a new LinkedCaseInsensitiveMap that wraps a `LinkedHashMap` with the given initial capacity and stores lower-case keys according to the given Locale.
    `LinkedCaseInsensitiveMap(Locale locale)` Create a new LinkedCaseInsensitiveMap that stores lower-case keys according to the given Locale.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clear()`
    `boolean` | `containsKey(Object key)`
    `protected String` | `convertKey(String key)` Convert the given key to a case-insensitive key.
    `V` | `get(Object key)`
    `V` | `put(String key, V value)`
    `void` | `putAll(Map<? extends String,? extends V> map)`
    `V` | `remove(Object key)`

    - ### Methods inherited from class java.util.LinkedHashMap

      `containsValue, entrySet, forEach, getOrDefault, keySet, removeEldestEntry, replaceAll, values`

    - ### Methods inherited from class java.util.HashMap

      `clone, compute, computeIfAbsent, computeIfPresent, isEmpty, merge, putIfAbsent, remove, replace, replace, size`

    - ### Methods inherited from class java.util.AbstractMap

      `equals, hashCode, toString`

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

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

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

      `compute, computeIfAbsent, computeIfPresent, equals, hashCode, isEmpty, merge, putIfAbsent, remove, replace, replace, size`

- - ### Constructor Detail

    - #### LinkedCaseInsensitiveMap

          public LinkedCaseInsensitiveMap()

      Create a new LinkedCaseInsensitiveMap for the default Locale.
      See Also:
        `String.toLowerCase()`

    - #### LinkedCaseInsensitiveMap

          public LinkedCaseInsensitiveMap(Locale locale)

      Create a new LinkedCaseInsensitiveMap that stores lower-case keys according to the given Locale.
      Parameters:
        `locale` - the Locale to use for lower-case conversion
      See Also:
        `String.toLowerCase(java.util.Locale)`

    - #### LinkedCaseInsensitiveMap

          public LinkedCaseInsensitiveMap(int initialCapacity)

      Create a new LinkedCaseInsensitiveMap that wraps a `LinkedHashMap` with the given initial capacity and stores lower-case keys according to the default Locale.
      Parameters:
        `initialCapacity` - the initial capacity
      See Also:
        `String.toLowerCase()`

    - #### LinkedCaseInsensitiveMap

          public LinkedCaseInsensitiveMap(int initialCapacity,
                                          Locale locale)

      Create a new LinkedCaseInsensitiveMap that wraps a `LinkedHashMap` with the given initial capacity and stores lower-case keys according to the given Locale.
      Parameters:
        `initialCapacity` - the initial capacity
        `locale` - the Locale to use for lower-case conversion
      See Also:
        `String.toLowerCase(java.util.Locale)`

  - ### Method Detail

    - #### put

          public V put(String key,
                       V value)

      Specified by:
        `put` in interface `Map<String,V>`
      Overrides:
        `put` in class `HashMap<String,V>`

    - #### putAll

          public void putAll(Map<? extends String,? extends V> map)

      Specified by:
        `putAll` in interface `Map<String,V>`
      Overrides:
        `putAll` in class `HashMap<String,V>`

    - #### containsKey

          public boolean containsKey(Object key)

      Specified by:
        `containsKey` in interface `Map<String,V>`
      Overrides:
        `containsKey` in class `HashMap<String,V>`

    - #### get

          public V get(Object key)

      Specified by:
        `get` in interface `Map<String,V>`
      Overrides:
        `get` in class `LinkedHashMap<String,V>`

    - #### remove

          public V remove(Object key)

      Specified by:
        `remove` in interface `Map<String,V>`
      Overrides:
        `remove` in class `HashMap<String,V>`

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `Map<String,V>`
      Overrides:
        `clear` in class `LinkedHashMap<String,V>`

    - #### convertKey

          protected String convertKey(String key)

      Convert the given key to a case-insensitive key.

      The default implementation converts the key to lower-case according to this Map's Locale.

      Parameters:
        `key` - the user-specified key
      Returns:
        the key to use for storing
      See Also:
        `String.toLowerCase(java.util.Locale)`