ConcurrentCharMap (mini2Dx-core 2.0.0-beta.7 API)

java.lang.Object
- org.mini2Dx.core.collections.CharMap<T>
- - org.mini2Dx.core.collections.concurrent.ConcurrentCharMap<T>

All Implemented Interfaces:: java.lang.Iterable<CharMap.Entry<T>>, ConcurrentCollection

public class ConcurrentCharMap<T>
extends CharMap<T>
implements ConcurrentCollection

Nested Class Summary
- Nested classes/interfaces inherited from class org.mini2Dx.core.collections.CharMap
  CharMap.Entries<V>, CharMap.Entry<V>, CharMap.Keys, CharMap.Values<V>

Field Summary

Fields
Modifier and Type Field and Description

protected org.mini2Dx.lockprovider.ReadWriteLock lock
- Fields inherited from class org.mini2Dx.core.collections.CharMap
  size

Fields
Modifier and Type	Field and Description
`protected org.mini2Dx.lockprovider.ReadWriteLock`	`lock`

Constructor Summary

Constructors
Constructor and Description
`ConcurrentCharMap()` Creates a new map with an initial capacity of 51 and a load factor of 0.8.
`ConcurrentCharMap(CharMap<? extends T> map)` Creates a new map identical to the specified map.
`ConcurrentCharMap(int initialCapacity)` Creates a new map with a load factor of 0.8.
`ConcurrentCharMap(int initialCapacity, float loadFactor)` Creates a new map with the specified initial capacity and load factor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`void`	`clear(int maximumCapacity)` Clears the map and reduces the size of the backing arrays to be the specified capacity if they are larger.
`boolean`	`containsKey(char key)`
`boolean`	`containsValue(java.lang.Object value, boolean identity)` Returns true if the specified value is in the map.
`void`	`ensureCapacity(int additionalCapacity)` Increases the size of the backing array to accommodate the specified number of additional items.
`CharMap.Entries<T>`	`entries()` Returns an iterator for the entries in the map.
`boolean`	`equals(java.lang.Object object)`
`char`	`findKey(java.lang.Object value, boolean identity, char notFound)` Returns the key for the specified value, or `notFound` if it is not in the map.
`T`	`get(char key, T defaultValue)`
`org.mini2Dx.lockprovider.ReadWriteLock`	`getLock()` Returns the collection's `ReadWriteLock`
`int`	`hashCode()`
`CharMap.Keys`	`keys()` Returns an iterator for the keys in the map.
`T`	`put(char key, T value)`
`void`	`putAll(CharMap<T> map)`
`boolean`	`putIfAbsent(char key, T value)` Puts a key/value if the key is not already present
`boolean`	`putIfPresent(char key, T value)` Puts a key/value if the key is already present
`T`	`remove(char key)`
`void`	`shrink(int maximumCapacity)` Reduces the size of the backing arrays to be the specified capacity or less.
`int`	`size()` Returns the size in a thread-safe manner
`java.lang.String`	`toString()`
`CharMap.Values<T>`	`values()` Returns an iterator for the values in the map.

Methods inherited from class org.mini2Dx.core.collections.CharMap
get, iterator

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - lock
```
protected org.mini2Dx.lockprovider.ReadWriteLock lock
```
- Constructor Detail
  - ConcurrentCharMap
```
public ConcurrentCharMap()
```
    Creates a new map with an initial capacity of 51 and a load factor of 0.8.
  - ConcurrentCharMap
```
public ConcurrentCharMap(int initialCapacity)
```
    Creates a new map with a load factor of 0.8.
    
    Parameters:
    
    initialCapacity - If not a power of two, it is increased to the next nearest power of two.
  - ConcurrentCharMap
```
public ConcurrentCharMap(int initialCapacity,
                         float loadFactor)
```
    Creates a new map with the specified initial capacity and load factor. This map will hold initialCapacity items before growing the backing table.
    
    Parameters:
    
    initialCapacity - If not a power of two, it is increased to the next nearest power of two.
    
    loadFactor -
  - ConcurrentCharMap
```
public ConcurrentCharMap(CharMap<? extends T> map)
```
    Creates a new map identical to the specified map. NOTE: read access to the other array is not thread-safe
    
    Parameters:
    
    map -
- Method Detail
  - size
```
public int size()
```
    Returns the size in a thread-safe manner
    
    Returns:
    
    0 if empty
  - put
```
public T put(char key,
             T value)
```
    Overrides:
    
    put in class CharMap<T>
  - putIfAbsent
```
public boolean putIfAbsent(char key,
                           T value)
```
    Puts a key/value if the key is not already present
    
    Parameters:
    
    key - The key to put if absent
    
    value - The value to put if absent
    
    Returns:
    
    True if the value was put
  - putIfPresent
```
public boolean putIfPresent(char key,
                            T value)
```
    Puts a key/value if the key is already present
    
    Parameters:
    
    key - The key to put if present
    
    value - The value to put if present
    
    Returns:
    
    True if the value was put
  - putAll
```
public void putAll(CharMap<T> map)
```
    Overrides:
    
    putAll in class CharMap<T>
  - get
```
public T get(char key,
             T defaultValue)
```
    Overrides:
    
    get in class CharMap<T>
  - remove
```
public T remove(char key)
```
    Overrides:
    
    remove in class CharMap<T>
  - shrink
```
public void shrink(int maximumCapacity)
```
    Description copied from class: CharMap
    
    Reduces the size of the backing arrays to be the specified capacity or less. If the capacity is already less, nothing is done. If the map contains more items than the specified capacity, the next highest power of two capacity is used instead.
    
    Overrides:
    
    shrink in class CharMap<T>
  - clear
```
public void clear(int maximumCapacity)
```
    Description copied from class: CharMap
    
    Clears the map and reduces the size of the backing arrays to be the specified capacity if they are larger.
    
    Overrides:
    
    clear in class CharMap<T>
  - clear
```
public void clear()
```
    Overrides:
    
    clear in class CharMap<T>
  - containsValue
```
public boolean containsValue(java.lang.Object value,
                             boolean identity)
```
    Description copied from class: CharMap
    
    Returns true if the specified value is in the map. Note this traverses the entire map and compares every value, which may be an expensive operation.
    
    Overrides:
    
    containsValue in class CharMap<T>
  - containsKey
```
public boolean containsKey(char key)
```
    Overrides:
    
    containsKey in class CharMap<T>
  - findKey
```
public char findKey(java.lang.Object value,
                    boolean identity,
                    char notFound)
```
    Description copied from class: CharMap
    
    Returns the key for the specified value, or notFound if it is not in the map. Note this traverses the entire map and compares every value, which may be an expensive operation.
    
    Overrides:
    
    findKey in class CharMap<T>
    
    identity - If true, uses == to compare the specified value with values in the map. If false, uses CharMap.equals(Object).
  - ensureCapacity
```
public void ensureCapacity(int additionalCapacity)
```
    Description copied from class: CharMap
    
    Increases the size of the backing array to accommodate the specified number of additional items. Useful before adding many items to avoid multiple backing array resizes.
    
    Overrides:
    
    ensureCapacity in class CharMap<T>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class CharMap<T>
  - equals
```
public boolean equals(java.lang.Object object)
```
    Overrides:
    
    equals in class CharMap<T>
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class CharMap<T>
  - entries
```
public CharMap.Entries<T> entries()
```
    Description copied from class: CharMap
    
    Returns an iterator for the entries in the map. Remove is supported. Note that the same iterator instance is returned each time this method is called. Use the CharMap.Entries constructor for nested or multithreaded iteration.
    
    Overrides:
    
    entries in class CharMap<T>
  - values
```
public CharMap.Values<T> values()
```
    Description copied from class: CharMap
    
    Returns an iterator for the values in the map. Remove is supported. Note that the same iterator instance is returned each time this method is called. Use the CharMap.Entries constructor for nested or multithreaded iteration.
    
    Overrides:
    
    values in class CharMap<T>
  - keys
```
public CharMap.Keys keys()
```
    Description copied from class: CharMap
    
    Returns an iterator for the keys in the map. Remove is supported. Note that the same iterator instance is returned each time this method is called. Use the CharMap.Entries constructor for nested or multithreaded iteration.
    
    Overrides:
    
    keys in class CharMap<T>
  - getLock
```
public org.mini2Dx.lockprovider.ReadWriteLock getLock()
```
    Description copied from interface: ConcurrentCollection
    
    Returns the collection's ReadWriteLock
    
    Specified by:
    
    getLock in interface ConcurrentCollection
    
    Returns:
    
    the collection's ReadWriteLock

Class ConcurrentCharMap<T>

Nested Class Summary

Nested classes/interfaces inherited from class org.mini2Dx.core.collections.CharMap

Field Summary

Fields inherited from class org.mini2Dx.core.collections.CharMap

Constructor Summary

Method Summary

Methods inherited from class org.mini2Dx.core.collections.CharMap

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

lock

Constructor Detail

ConcurrentCharMap

ConcurrentCharMap

ConcurrentCharMap

ConcurrentCharMap

Method Detail

size

put

putIfAbsent

putIfPresent

putAll

get

remove

shrink

clear

clear

containsValue

containsKey

findKey

ensureCapacity

hashCode

equals

toString

entries

values

keys

getLock