## 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
`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
`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, removeEldestEntry`

Methods inherited from class java.util.HashMap
`clone, entrySet, isEmpty, keySet, size, values`

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
`entrySet, equals, hashCode, isEmpty, keySet, size, values`

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)`