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

java.lang.Object
- org.mini2Dx.core.collections.ByteMap<T>
- - org.mini2Dx.core.collections.concurrent.ConcurrentByteMap<T>

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

public class ConcurrentByteMap<T>
extends ByteMap<T>
implements ConcurrentCollection

Nested Class Summary
- Nested classes/interfaces inherited from class org.mini2Dx.core.collections.ByteMap
  ByteMap.Entries<V>, ByteMap.Entry<V>, ByteMap.Keys, ByteMap.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.ByteMap
  size

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

Constructor Summary

Constructors
Constructor and Description
`ConcurrentByteMap()` Creates a new map with an initial capacity of 51 and a load factor of 0.8.
`ConcurrentByteMap(ByteMap<? extends T> map)` Creates a new map identical to the specified map.
`ConcurrentByteMap(int initialCapacity)` Creates a new map with a load factor of 0.8.
`ConcurrentByteMap(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(byte 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.
`ByteMap.Entries<T>`	`entries()` Returns an iterator for the entries in the map.
`boolean`	`equals(java.lang.Object object)`
`byte`	`findKey(java.lang.Object value, boolean identity, byte notFound)` Returns the key for the specified value, or `notFound` if it is not in the map.
`T`	`get(byte key, T defaultValue)`
`org.mini2Dx.lockprovider.ReadWriteLock`	`getLock()` Returns the collection's `ReadWriteLock`
`int`	`hashCode()`
`ByteMap.Keys`	`keys()` Returns an iterator for the keys in the map.
`T`	`put(byte key, T value)`
`void`	`putAll(ByteMap<T> map)`
`boolean`	`putIfAbsent(byte key, T value)` Puts a key/value if the key is not already present
`boolean`	`putIfPresent(byte key, T value)` Puts a key/value if the key is already present
`T`	`remove(byte 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()`
`ByteMap.Values<T>`	`values()` Returns an iterator for the values in the map.

Methods inherited from class org.mini2Dx.core.collections.ByteMap
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
  - ConcurrentByteMap
```
public ConcurrentByteMap()
```
    Creates a new map with an initial capacity of 51 and a load factor of 0.8.
  - ConcurrentByteMap
```
public ConcurrentByteMap(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.
  - ConcurrentByteMap
```
public ConcurrentByteMap(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 -
  - ConcurrentByteMap
```
public ConcurrentByteMap(ByteMap<? extends T> map)
```
    Creates a new map identical to the specified map. NOTE: read access to the other map 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(byte key,
             T value)
```
    Overrides:
    
    put in class ByteMap<T>
  - putIfAbsent
```
public boolean putIfAbsent(byte 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(byte 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(ByteMap<T> map)
```
    Overrides:
    
    putAll in class ByteMap<T>
  - get
```
public T get(byte key,
             T defaultValue)
```
    Overrides:
    
    get in class ByteMap<T>
  - remove
```
public T remove(byte key)
```
    Overrides:
    
    remove in class ByteMap<T>
  - shrink
```
public void shrink(int maximumCapacity)
```
    Description copied from class: ByteMap
    
    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 ByteMap<T>
  - clear
```
public void clear(int maximumCapacity)
```
    Description copied from class: ByteMap
    
    Clears the map and reduces the size of the backing arrays to be the specified capacity if they are larger.
    
    Overrides:
    
    clear in class ByteMap<T>
  - clear
```
public void clear()
```
    Overrides:
    
    clear in class ByteMap<T>
  - containsValue
```
public boolean containsValue(java.lang.Object value,
                             boolean identity)
```
    Description copied from class: ByteMap
    
    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 ByteMap<T>
  - containsKey
```
public boolean containsKey(byte key)
```
    Overrides:
    
    containsKey in class ByteMap<T>
  - findKey
```
public byte findKey(java.lang.Object value,
                    boolean identity,
                    byte notFound)
```
    Description copied from class: ByteMap
    
    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 ByteMap<T>
    
    identity - If true, uses == to compare the specified value with values in the map. If false, uses ByteMap.equals(Object).
  - ensureCapacity
```
public void ensureCapacity(int additionalCapacity)
```
    Description copied from class: ByteMap
    
    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 ByteMap<T>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class ByteMap<T>
  - equals
```
public boolean equals(java.lang.Object object)
```
    Overrides:
    
    equals in class ByteMap<T>
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class ByteMap<T>
  - entries
```
public ByteMap.Entries<T> entries()
```
    Description copied from class: ByteMap
    
    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 ByteMap.Entries constructor for nested or multithreaded iteration.
    
    Overrides:
    
    entries in class ByteMap<T>
  - values
```
public ByteMap.Values<T> values()
```
    Description copied from class: ByteMap
    
    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 ByteMap.Entries constructor for nested or multithreaded iteration.
    
    Overrides:
    
    values in class ByteMap<T>
  - keys
```
public ByteMap.Keys keys()
```
    Description copied from class: ByteMap
    
    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 ByteMap.Entries constructor for nested or multithreaded iteration.
    
    Overrides:
    
    keys in class ByteMap<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 ConcurrentByteMap<T>

Nested Class Summary

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

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

lock

Constructor Detail

ConcurrentByteMap

ConcurrentByteMap

ConcurrentByteMap

ConcurrentByteMap

Method Detail

size

put

putIfAbsent

putIfPresent

putAll

get

remove

shrink

clear

clear

containsValue

containsKey

findKey

ensureCapacity

hashCode

equals

toString

entries

values

keys

getLock