io.vertx.core.shareddata

## Interface LocalMap<K,V>

-     public interface LocalMap<K,V>

  Local maps can be used to share data safely in a single Vert.x instance.

  The map only allows immutable keys and values in the map, OR certain mutable objects such as `Buffer` instances which will be copied when they are added to the map.

  This ensures there is no shared access to mutable state from different threads (e.g. different event loops) in the Vert.x instance, and means you don't have to protect access to that state using synchronization or locks.

  Author:
    Tim Fox

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clear()` Clear all entries in the map
    `void` | `close()` Close and release the map
    `V` | `get(K key)` Get a value from the map
    `boolean` | `isEmpty()`
    `Set<K>` | `keySet()`
    `V` | `put(K key, V value)` Put an entry in the map
    `V` | `putIfAbsent(K key, V value)` Put the entry only if there is no existing entry for that key
    `V` | `remove(K key)` Remove an entry from the map
    `boolean` | `removeIfPresent(K key, V value)` Remove the entry only if there is an entry with the specified key and value
    `V` | `replace(K key, V value)` Replace the entry only if there is an existing entry with the key
    `boolean` | `replaceIfPresent(K key, V oldValue, V newValue)` Replace the entry only if there is an existing entry with the specified key and value
    `int` | `size()` Get the size of the map
    `Collection<V>` | `values()`

- - ### Method Detail

    - #### get

          V get(K key)

      Get a value from the map
      Parameters:
        `key` - the key
      Returns:
        the value, or null if none

    - #### put

          V put(K key,
                V value)

      Put an entry in the map
      Parameters:
        `key` - the key
        `value` - the value
      Returns:
        return the old value, or null if none

    - #### remove

          V remove(K key)

      Remove an entry from the map
      Parameters:
        `key` - the key
      Returns:
        the old value

    - #### clear

          void clear()

      Clear all entries in the map

    - #### size

          int size()

      Get the size of the map
      Returns:
        the number of entries in the map

    - #### isEmpty

          boolean isEmpty()

      Returns:
        true if there are zero entries in the map

    - #### putIfAbsent

          V putIfAbsent(K key,
                        V value)

      Put the entry only if there is no existing entry for that key
      Parameters:
        `key` - the key
        `value` - the value
      Returns:
        the old value or null, if none

    - #### removeIfPresent

          boolean removeIfPresent(K key,
                                  V value)

      Remove the entry only if there is an entry with the specified key and value
      Parameters:
        `key` - the key
        `value` - the value
      Returns:
        true if removed

    - #### replaceIfPresent

          boolean replaceIfPresent(K key,
                                   V oldValue,
                                   V newValue)

      Replace the entry only if there is an existing entry with the specified key and value
      Parameters:
        `key` - the key
        `oldValue` - the old value
        `newValue` - the new value
      Returns:
        true if removed

    - #### replace

          V replace(K key,
                    V value)

      Replace the entry only if there is an existing entry with the key
      Parameters:
        `key` - the key
        `value` - the new value
      Returns:
        the old value

    - #### close

          void close()

      Close and release the map

    - #### keySet

          Set<K> keySet()

      Returns:
        the set of keys in the map

    - #### values

          Collection<V> values()

      Returns:
        the set of values in the map

Copyright © 2015. All rights reserved.