TConcurrentHashMap (Bytecoder java.base Module 2021-11-02 API)

java.lang.Object
- java.util.AbstractMap<K,V>
- - de.mirkosertic.bytecoder.classlib.java.util.concurrent.TConcurrentHashMap<K,V>

All Implemented Interfaces:: Serializable, ConcurrentMap<K,V>, Map<K,V>

public class TConcurrentHashMap<K,V>
extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable

See Also:: Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`TConcurrentHashMap.CollectionView<K>`
`static class`	`TConcurrentHashMap.EntrySetView<K,V>`
`static class`	`TConcurrentHashMap.KeySetView<K>`
`static class`	`TConcurrentHashMap.ValuesView<V>`

Nested classes/interfaces inherited from class java.util.AbstractMap
AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

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

Constructor Summary

Constructors
Constructor and Description
`TConcurrentHashMap()`
`TConcurrentHashMap(int initialCapacity)`
`TConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)`
`TConcurrentHashMap(Map<K,V> data)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`V`	`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`
`V`	`computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)`
`V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`
`boolean`	`contains(Object o)`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`boolean`	`equals(Object o)`
`void`	`forEach(BiConsumer<? super K,? super V> action)`
`V`	`get(Object key)`
`V`	`getOrDefault(Object key, V defaultValue)`
`int`	`hashCode()`
`boolean`	`isEmpty()`
`ConcurrentHashMap.KeySetView`	`keySet()`
`long`	`mappingCount()`
`V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)`
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> m)`
`V`	`putIfAbsent(K key, V value)`
`V`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`V`	`replace(K key, V value)`
`boolean`	`replace(K key, V oldValue, V newValue)`
`void`	`replaceAll(BiFunction<? super K,? super V,? extends V> function)`
`int`	`size()`
`String`	`toString()`
`Collection<V>`	`values()`

Methods inherited from class java.util.AbstractMap
clone

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

- Constructor Detail
  - TConcurrentHashMap
```
public TConcurrentHashMap()
```
  - TConcurrentHashMap
```
public TConcurrentHashMap(int initialCapacity)
```
  - TConcurrentHashMap
```
public TConcurrentHashMap(int initialCapacity,
                          float loadFactor,
                          int concurrencyLevel)
```
  - TConcurrentHashMap
```
public TConcurrentHashMap(Map<K,V> data)
```
- Method Detail
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface Map<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
    
    Specified by:
    
    entrySet in class AbstractMap<K,V>
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface ConcurrentMap<K,V>
    
    Specified by:
    
    remove in interface Map<K,V>
  - replace
```
public V replace(K key,
                 V value)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - getOrDefault
```
public V getOrDefault(Object key,
                      V defaultValue)
```
    Specified by:
    
    getOrDefault in interface ConcurrentMap<K,V>
    
    Specified by:
    
    getOrDefault in interface Map<K,V>
  - forEach
```
public void forEach(BiConsumer<? super K,? super V> action)
```
    Specified by:
    
    forEach in interface ConcurrentMap<K,V>
    
    Specified by:
    
    forEach in interface Map<K,V>
  - replaceAll
```
public void replaceAll(BiFunction<? super K,? super V,? extends V> function)
```
    Specified by:
    
    replaceAll in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replaceAll in interface Map<K,V>
  - computeIfAbsent
```
public V computeIfAbsent(K key,
                         Function<? super K,? extends V> mappingFunction)
```
    Specified by:
    
    computeIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    computeIfAbsent in interface Map<K,V>
  - computeIfPresent
```
public V computeIfPresent(K key,
                          BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    computeIfPresent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    computeIfPresent in interface Map<K,V>
  - compute
```
public V compute(K key,
                 BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    compute in interface ConcurrentMap<K,V>
    
    Specified by:
    
    compute in interface Map<K,V>
  - merge
```
public V merge(K key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    merge in interface ConcurrentMap<K,V>
    
    Specified by:
    
    merge in interface Map<K,V>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
    
    Overrides:
    
    size in class AbstractMap<K,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
    
    Overrides:
    
    isEmpty in class AbstractMap<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
    
    Overrides:
    
    containsValue in class AbstractMap<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
    
    Overrides:
    
    containsKey in class AbstractMap<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
    
    Overrides:
    
    get in class AbstractMap<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
    
    Overrides:
    
    put in class AbstractMap<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
    
    Overrides:
    
    remove in class AbstractMap<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> m)
```
    Specified by:
    
    putAll in interface Map<K,V>
    
    Overrides:
    
    putAll in class AbstractMap<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
    
    Overrides:
    
    clear in class AbstractMap<K,V>
  - keySet
```
public ConcurrentHashMap.KeySetView keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
    
    Overrides:
    
    keySet in class AbstractMap<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
    
    Overrides:
    
    values in class AbstractMap<K,V>
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Map<K,V>
    
    Overrides:
    
    equals in class AbstractMap<K,V>
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<K,V>
    
    Overrides:
    
    hashCode in class AbstractMap<K,V>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class AbstractMap<K,V>
  - contains
```
public boolean contains(Object o)
```
  - mappingCount
```
public long mappingCount()
```

Class TConcurrentHashMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Constructor Detail

TConcurrentHashMap

TConcurrentHashMap

TConcurrentHashMap

TConcurrentHashMap

Method Detail

putIfAbsent

entrySet

remove

replace

replace

getOrDefault

forEach

replaceAll

computeIfAbsent

computeIfPresent

compute

merge

size

isEmpty

containsValue

containsKey

get

put

remove

putAll

clear

keySet

values

equals

hashCode

toString

contains

mappingCount