Class StaticBucketMap<K,V> 
- Type Parameters:
- K- the type of the keys in this map
- V- the type of the values in this map
- All Implemented Interfaces:
- Map<K,,- V> - Get<K,,- V> - IterableGet<K,,- V> - IterableMap<K,,- V> - Put<K,- V> 
Map that performs well in a highly
 thread-contentious environment.
 
 The map supports very efficient
 get, put,
 remove and containsKey
 operations, assuming (approximate) uniform hashing and
 that the number of entries does not exceed the number of buckets.  If the
 number of entries exceeds the number of buckets or if the hash codes of the
 objects are not uniformly distributed, these operations have a worst case
 scenario that is proportional to the number of elements in the map
 (O(n)).
 
 Each bucket in the hash table has its own monitor, so two threads can
 safely operate on the map at the same time, often without incurring any
 monitor contention.  This means that you don't have to wrap instances
 of this class with Collections.synchronizedMap(Map);
 instances are already thread-safe.  Unfortunately, however, this means
 that this map implementation behaves in ways you may find disconcerting.
 Bulk operations, such as putAll or the
 retainAll operation in collection
 views, are not atomic.  If two threads are simultaneously
 executing
 
staticBucketMapInstance.putAll(map);and
staticBucketMapInstance.entrySet().removeAll(map.entrySet());
 then the results are generally random.  Those two statement could cancel
 each other out, leaving staticBucketMapInstance essentially
 unchanged, or they could leave some random subset of map in
 staticBucketMapInstance.
 
 Also, much like an encyclopedia, the results of size() and
 isEmpty() are out-of-date as soon as they are produced.
 
 The iterators returned by the collection views of this class are not
 fail-fast.  They will never raise a
 ConcurrentModificationException.  Keys and values
 added to the map after the iterator is created do not necessarily appear
 during iteration.  Similarly, the iterator does not necessarily fail to
 return keys and values that were removed after the iterator was created.
 
 Finally, unlike HashMap-style implementations, this
 class never rehashes the map.  The number of buckets is fixed
 at construction time and never altered.  Performance may degrade if
 you do not allocate enough buckets upfront.
 
 The atomic(Runnable) method is provided to allow atomic iterations
 and bulk operations; however, overuse of atomic
 will basically result in a map that's slower than an ordinary synchronized
 HashMap.
 
Use this class if you do not require reliable bulk operations and iterations, or if you can make your own guarantees about how bulk operations will affect the map.
- Since:
- 3.0 (previously in main package v2.1)
- 
Nested Class Summary
- 
Constructor SummaryConstructorsConstructorDescriptionInitializes the map with the default number of buckets (255).StaticBucketMap(int numBuckets) Initializes the map with a specified number of buckets.
- 
Method SummaryModifier and TypeMethodDescriptionvoidPrevents any operations from occurring on this map while the givenRunnableexecutes.voidclear()Clears the map of all entries.booleancontainsKey(Object key) Checks if the map contains the specified key.booleancontainsValue(Object value) Checks if the map contains the specified value.entrySet()Gets the entry set.booleanCompares this map to another, as per the Map specification.Gets the value associated with the key.inthashCode()Gets the hash code, as per the Map specification.booleanisEmpty()Checks if the size is currently zero.keySet()Gets the key set.Puts a new key value mapping into the map.voidPuts all the entries from the specified map into this map.Removes the specified key from the map.intsize()Gets the current size of the map.values()Gets the values.Methods inherited from class org.apache.commons.collections4.map.AbstractIterableMapmapIteratorMethods inherited from class java.lang.Objectclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitMethods inherited from interface java.util.Mapcompute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll
- 
Constructor Details- 
StaticBucketMappublic StaticBucketMap()Initializes the map with the default number of buckets (255).
- 
StaticBucketMapInitializes the map with a specified number of buckets. The number of buckets is never below 17, and is always an odd number (StaticBucketMap ensures this). The number of buckets is inversely proportional to the chances for thread contention. The fewer buckets, the more chances for thread contention. The more buckets the fewer chances for thread contention.- Parameters:
- numBuckets- the number of buckets for this map
 
 
- 
- 
Method Details- 
atomicPrevents any operations from occurring on this map while the givenRunnableexecutes. This method can be used, for instance, to execute a bulk operation atomically:staticBucketMapInstance.atomic(new Runnable() { public void run() { staticBucketMapInstance.putAll(map); } });It can also be used if you need a reliable iterator: staticBucketMapInstance.atomic(new Runnable() { public void run() { Iterator iterator = staticBucketMapInstance.iterator(); while (iterator.hasNext()) { foo(iterator.next(); } } });Implementation note: This method requires a lot of time and a ton of stack space. Essentially a recursive algorithm is used to enter each bucket's monitor. If you have twenty thousand buckets in your map, then the recursive method will be invoked twenty thousand times. You have been warned. - Parameters:
- runnable- the code to execute atomically
 
- 
clear
- 
containsKeyChecks if the map contains the specified key.- Parameters:
- key- the key to check
- Returns:
- true if found
- See Also:
 
- 
containsValueChecks if the map contains the specified value.- Parameters:
- value- the value to check
- Returns:
- true if found
- See Also:
 
- 
entrySet
- 
equals
- 
get
- 
hashCode
- 
isEmpty
- 
keySet
- 
put
- 
putAll
- 
remove
- 
sizeGets the current size of the map. The value is computed fresh each time the method is called.- Returns:
- the current size
- See Also:
 
- 
values
 
-