AtomicLongMap (Guava: Google Core Libraries for Java 27.1-jre API)

java.lang.Object
- com.google.common.util.concurrent.AtomicLongMap<K>

All Implemented Interfaces:

Serializable
```
@GwtCompatible
public final class AtomicLongMap<K>
extends Object
implements Serializable
```
A map containing long values that can be atomically updated. While writes to a traditional Map rely on put(K, V), the typical mechanism for writing to this map is addAndGet(K, long), which adds a long to the value currently associated with K. If a key has not yet been associated with a value, its implicit value is zero.
Most methods in this class treat absent values and zero values identically, as individually documented. Exceptions to this are containsKey(java.lang.Object), size(), isEmpty(), asMap, and toString().
Instances of this class may be used by multiple threads concurrently. All operations are atomic unless otherwise noted.
Note: If your values are always positive and less than 2^31, you may wish to use a Multiset such as ConcurrentHashMultiset instead.
Warning: Unlike Multiset, entries whose values are zero are not automatically removed from the map. Instead they must be removed manually with removeAllZeros().

Since:

11.0

Author:

Charles Fry

See Also:

Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`accumulateAndGet(K key, long x, LongBinaryOperator accumulatorFunction)` Updates the value currently associated with `key` by combining it with `x` via the specified accumulator function, returning the new value.
`long`	`addAndGet(K key, long delta)` Adds `delta` to the value currently associated with `key`, and returns the new value.
`Map<K,Long>`	`asMap()` Returns a live, read-only view of the map backing this `AtomicLongMap`.
`void`	`clear()` Removes all of the mappings from this map.
`boolean`	`containsKey(Object key)` Returns true if this map contains a mapping for the specified key.
`static <K> AtomicLongMap<K>`	`create()` Creates an `AtomicLongMap`.
`static <K> AtomicLongMap<K>`	`create(Map<? extends K,? extends Long> m)` Creates an `AtomicLongMap` with the same mappings as the specified `Map`.
`long`	`decrementAndGet(K key)` Decrements by one the value currently associated with `key`, and returns the new value.
`long`	`get(K key)` Returns the value associated with `key`, or zero if there is no value associated with `key`.
`long`	`getAndAccumulate(K key, long x, LongBinaryOperator accumulatorFunction)` Updates the value currently associated with `key` by combining it with `x` via the specified accumulator function, returning the old value.
`long`	`getAndAdd(K key, long delta)` Adds `delta` to the value currently associated with `key`, and returns the old value.
`long`	`getAndDecrement(K key)` Decrements by one the value currently associated with `key`, and returns the old value.
`long`	`getAndIncrement(K key)` Increments by one the value currently associated with `key`, and returns the old value.
`long`	`getAndUpdate(K key, LongUnaryOperator updaterFunction)` Updates the value currently associated with `key` with the specified function, and returns the old value.
`long`	`incrementAndGet(K key)` Increments by one the value currently associated with `key`, and returns the new value.
`boolean`	`isEmpty()` Returns `true` if this map contains no key-value mappings.
`long`	`put(K key, long newValue)` Associates `newValue` with `key` in this map, and returns the value previously associated with `key`, or zero if there was no such value.
`void`	`putAll(Map<? extends K,? extends Long> m)` Copies all of the mappings from the specified map to this map.
`long`	`remove(K key)` Removes and returns the value associated with `key`.
`void`	`removeAllZeros()` Removes all mappings from this map whose values are zero.
`boolean`	`removeIfZero(K key)` Atomically remove `key` from the map iff its associated value is 0.
`int`	`size()` Returns the number of key-value mappings in this map.
`long`	`sum()` Returns the sum of all values in this map.
`String`	`toString()` Returns a string representation of the object.
`long`	`updateAndGet(K key, LongUnaryOperator updaterFunction)` Updates the value currently associated with `key` with the specified function, and returns the new value.

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

- Method Detail
  - create
```
public static <K> AtomicLongMap<K> create()
```
    Creates an AtomicLongMap.
  - create
```
public static <K> AtomicLongMap<K> create(Map<? extends K,? extends Long> m)
```
    Creates an AtomicLongMap with the same mappings as the specified Map.
  - get
```
public long get(K key)
```
    Returns the value associated with key, or zero if there is no value associated with key.
  - incrementAndGet
```
@CanIgnoreReturnValue
public long incrementAndGet(K key)
```
    Increments by one the value currently associated with key, and returns the new value.
  - decrementAndGet
```
@CanIgnoreReturnValue
public long decrementAndGet(K key)
```
    Decrements by one the value currently associated with key, and returns the new value.
  - addAndGet
```
@CanIgnoreReturnValue
public long addAndGet(K key,
                                            long delta)
```
    Adds delta to the value currently associated with key, and returns the new value.
  - getAndIncrement
```
@CanIgnoreReturnValue
public long getAndIncrement(K key)
```
    Increments by one the value currently associated with key, and returns the old value.
  - getAndDecrement
```
@CanIgnoreReturnValue
public long getAndDecrement(K key)
```
    Decrements by one the value currently associated with key, and returns the old value.
  - getAndAdd
```
@CanIgnoreReturnValue
public long getAndAdd(K key,
                                            long delta)
```
    Adds delta to the value currently associated with key, and returns the old value.
  - updateAndGet
```
@CanIgnoreReturnValue
public long updateAndGet(K key,
                                               LongUnaryOperator updaterFunction)
```
    Updates the value currently associated with key with the specified function, and returns the new value. If there is not currently a value associated with key, the function is applied to 0L.
    
    Since:
    
    21.0
  - getAndUpdate
```
@CanIgnoreReturnValue
public long getAndUpdate(K key,
                                               LongUnaryOperator updaterFunction)
```
    Updates the value currently associated with key with the specified function, and returns the old value. If there is not currently a value associated with key, the function is applied to 0L.
    
    Since:
    
    21.0
  - accumulateAndGet
```
@CanIgnoreReturnValue
public long accumulateAndGet(K key,
                                                   long x,
                                                   LongBinaryOperator accumulatorFunction)
```
    Updates the value currently associated with key by combining it with x via the specified accumulator function, returning the new value. The previous value associated with key (or zero, if there is none) is passed as the first argument to accumulatorFunction, and x is passed as the second argument.
    
    Since:
    
    21.0
  - getAndAccumulate
```
@CanIgnoreReturnValue
public long getAndAccumulate(K key,
                                                   long x,
                                                   LongBinaryOperator accumulatorFunction)
```
    Updates the value currently associated with key by combining it with x via the specified accumulator function, returning the old value. The previous value associated with key (or zero, if there is none) is passed as the first argument to accumulatorFunction, and x is passed as the second argument.
    
    Since:
    
    21.0
  - put
```
@CanIgnoreReturnValue
public long put(K key,
                                      long newValue)
```
    Associates newValue with key in this map, and returns the value previously associated with key, or zero if there was no such value.
  - putAll
```
public void putAll(Map<? extends K,? extends Long> m)
```
    Copies all of the mappings from the specified map to this map. The effect of this call is equivalent to that of calling put(k, v) on this map once for each mapping from key k to value v in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress.
  - remove
```
@CanIgnoreReturnValue
public long remove(K key)
```
    Removes and returns the value associated with key. If key is not in the map, this method has no effect and returns zero.
  - removeIfZero
```
@Beta
 @CanIgnoreReturnValue
public boolean removeIfZero(K key)
```
    Atomically remove key from the map iff its associated value is 0.
    
    Since:
    
    20.0
  - removeAllZeros
```
public void removeAllZeros()
```
    Removes all mappings from this map whose values are zero.
    This method is not atomic: the map may be visible in intermediate states, where some of the zero values have been removed and others have not.
  - sum
```
public long sum()
```
    Returns the sum of all values in this map.
    This method is not atomic: the sum may or may not include other concurrent operations.
  - asMap
```
public Map<K,Long> asMap()
```
    Returns a live, read-only view of the map backing this AtomicLongMap.
  - containsKey
```
public boolean containsKey(Object key)
```
    Returns true if this map contains a mapping for the specified key.
  - size
```
public int size()
```
    Returns the number of key-value mappings in this map. If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
  - isEmpty
```
public boolean isEmpty()
```
    Returns true if this map contains no key-value mappings.
  - clear
```
public void clear()
```
    Removes all of the mappings from this map. The map will be empty after this call returns.
    This method is not atomic: the map may not be empty after returning if there were concurrent writes.
  - toString
```
public String toString()
```
    Description copied from class: java.lang.Object
    Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.
    The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
    getClass().getName() + '@' + Integer.toHexString(hashCode())
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a string representation of the object.

Class AtomicLongMap<K>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

create

create

get

incrementAndGet

decrementAndGet

addAndGet

getAndIncrement

getAndDecrement

getAndAdd

updateAndGet

getAndUpdate

accumulateAndGet

getAndAccumulate

put

putAll

remove

removeIfZero

removeAllZeros

sum

asMap

containsKey

size

isEmpty

clear

toString