CharArrayMap (Lucene 3.6.2 API)
Keywords: org.apache.lucene.analysis.CharArrayMap class

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.lucene.analysis
Class CharArrayMap<V>

    java.lang.Object
      java.util.AbstractMap<Object,V>
          org.apache.lucene.analysis.CharArrayMap<V>

All Implemented Interfaces:
  Map<Object,V>

    public class CharArrayMap<V>

extends AbstractMap<Object,V>

A simple class that stores key Strings as char[]'s in a hash table. Note that this is not a general purpose class. For example, it cannot remove items from the map, nor does it resize its hash table to be smaller, etc. It is designed to be quick to retrieve items by char[] keys without the necessity of converting to a String first.

You must specify the required `Version` compatibility when creating `CharArrayMap`:

- As of 3.1, supplementary characters are properly lowercased.

Before 3.1 supplementary characters could not be lowercased correctly due to the lack of Unicode 4 support in JDK 1.4. To use instances of `CharArrayMap` with the behavior before Lucene 3.1 pass a `Version` < 3.1 to the constructors.

Nested Class Summary
`class` | `CharArrayMap.EntryIterator` public iterator class so efficient methods are exposed to users
`class` | `CharArrayMap.EntrySet` public EntrySet class so efficient methods are exposed to users

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

Constructor Summary
`CharArrayMap(Version matchVersion, int startSize, boolean ignoreCase)` Create map with enough capacity to hold startSize terms
`CharArrayMap(Version matchVersion, Map<?,? extends V> c, boolean ignoreCase)` Creates a map from the mappings in another map.

Method Summary
`void` | `clear()` Clears all entries in this map.
`boolean` | `containsKey(char[] text, int off, int len)` true if the `len` chars of `text` starting at `off` are in the `keySet`
`boolean` | `containsKey(CharSequence cs)` true if the `CharSequence` is in the `keySet`
`boolean` | `containsKey(Object o)`
`static
`<V> CharArrayMap<V>`
` | `copy(Version matchVersion, Map<?,? extends V> map)` Returns a copy of the given map as a `CharArrayMap`.
`static
`<V> CharArrayMap<V>`
` | `emptyMap()` Returns an empty, unmodifiable map.
`CharArrayMap.EntrySet` | `entrySet()`
`V` | `get(char[] text, int off, int len)` returns the value of the mapping of `len` chars of `text` starting at `off`
`V` | `get(CharSequence cs)` returns the value of the mapping of the chars inside this `CharSequence`
`V` | `get(Object o)`
`CharArraySet` | `keySet()` Returns an `CharArraySet` view on the map's keys.
`V` | `put(char[] text, V value)` Add the given mapping.
`V` | `put(CharSequence text, V value)` Add the given mapping.
`V` | `put(Object o, V value)`
`V` | `put(String text, V value)` Add the given mapping.
`V` | `remove(Object key)`
`int` | `size()`
`String` | `toString()`
`static
`<V> CharArrayMap<V>`
` | `unmodifiableMap(CharArrayMap<V> map)` Returns an unmodifiable `CharArrayMap`.

Methods inherited from class java.util.AbstractMap
`clone, containsValue, equals, hashCode, isEmpty, putAll, values`

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

Constructor Detail

### CharArrayMap

    public CharArrayMap(Version matchVersion,
                        int startSize,
                        boolean ignoreCase)

  Create map with enough capacity to hold startSize terms

  Parameters:
    `matchVersion` - compatibility match version see Version note above for details.
    `startSize` - the initial capacity
    `ignoreCase` - `false` if and only if the set should be case sensitive otherwise `true`.

### CharArrayMap

    public CharArrayMap(Version matchVersion,
                        Map<?,? extends V> c,
                        boolean ignoreCase)

  Creates a map from the mappings in another map.

  Parameters:
    `matchVersion` - compatibility match version see Version note above for details.
    `c` - a map whose mappings to be copied
    `ignoreCase` - `false` if and only if the set should be case sensitive otherwise `true`.

Method Detail

### clear

    public void clear()

  Clears all entries in this map. This method is supported for reusing, but not `Map.remove(java.lang.Object)`.

  Specified by:
    `clear` in interface `Map<Object,V>`
  Overrides:
    `clear` in class `AbstractMap<Object,V>`

### containsKey

    public boolean containsKey(char[] text,
                               int off,
                               int len)

  true if the `len` chars of `text` starting at `off` are in the `keySet`

### containsKey

    public boolean containsKey(CharSequence cs)

  true if the `CharSequence` is in the `keySet`

### containsKey

    public boolean containsKey(Object o)

  Specified by:
    `containsKey` in interface `Map<Object,V>`
  Overrides:
    `containsKey` in class `AbstractMap<Object,V>`

### get

    public V get(char[] text,
                 int off,
                 int len)

  returns the value of the mapping of `len` chars of `text` starting at `off`

### get

    public V get(CharSequence cs)

  returns the value of the mapping of the chars inside this `CharSequence`

### get

    public V get(Object o)

  Specified by:
    `get` in interface `Map<Object,V>`
  Overrides:
    `get` in class `AbstractMap<Object,V>`

### put

    public V put(CharSequence text,
                 V value)

  Add the given mapping.

### put

    public V put(Object o,
                 V value)

  Specified by:
    `put` in interface `Map<Object,V>`
  Overrides:
    `put` in class `AbstractMap<Object,V>`

### put

    public V put(String text,
                 V value)

  Add the given mapping.

### put

    public V put(char[] text,
                 V value)

  Add the given mapping. If ignoreCase is true for this Set, the text array will be directly modified. The user should never modify this text array after calling this method.

### remove

    public V remove(Object key)

  Specified by:
    `remove` in interface `Map<Object,V>`
  Overrides:
    `remove` in class `AbstractMap<Object,V>`

### size

    public int size()

  Specified by:
    `size` in interface `Map<Object,V>`
  Overrides:
    `size` in class `AbstractMap<Object,V>`

### toString

    public String toString()

  Overrides:
    `toString` in class `AbstractMap<Object,V>`

### entrySet

    public final CharArrayMap.EntrySet entrySet()

  Specified by:
    `entrySet` in interface `Map<Object,V>`
  Specified by:
    `entrySet` in class `AbstractMap<Object,V>`

### keySet

    public final CharArraySet keySet()

  Returns an `CharArraySet` view on the map's keys. The set will use the same `matchVersion` as this map.

  Specified by:
    `keySet` in interface `Map<Object,V>`
  Overrides:
    `keySet` in class `AbstractMap<Object,V>`

### unmodifiableMap

    public static <V> CharArrayMap<V> unmodifiableMap(CharArrayMap<V> map)

  Returns an unmodifiable `CharArrayMap`. This allows to provide unmodifiable views of internal map for "read-only" use.

  Parameters:
    `map` - a map for which the unmodifiable map is returned.
  Returns:
    an new unmodifiable `CharArrayMap`.
  Throws:
    `NullPointerException` - if the given map is `null`.

### copy

    public static <V> CharArrayMap<V> copy(Version matchVersion,
                                           Map<?,? extends V> map)

  Returns a copy of the given map as a `CharArrayMap`. If the given map is a `CharArrayMap` the ignoreCase property will be preserved.

  Note: If you intend to create a copy of another `CharArrayMap` where the `Version` of the source map differs from its copy `CharArrayMap(Version, Map, boolean)` should be used instead. The `copy(Version, Map)` will preserve the `Version` of the source map it is an instance of `CharArrayMap`.

  Parameters:
    `matchVersion` - compatibility match version see Version note above for details. This argument will be ignored if the given map is a `CharArrayMap`.
    `map` - a map to copy
  Returns:
    a copy of the given map as a `CharArrayMap`. If the given map is a `CharArrayMap` the ignoreCase property as well as the matchVersion will be of the given map will be preserved.

### emptyMap

    public static <V> CharArrayMap<V> emptyMap()

  Returns an empty, unmodifiable map.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD