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

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