com.hazelcast.core
K - keyV - valuepublic interface IMap<K,V> extends ConcurrentMap<K,V>, BaseMap<K,V>
This class is not a general-purpose ConcurrentMap implementation! While this class implements the Map interface, it intentionally violates Map's general contract, which mandates the use of the equals method when comparing objects. Instead of the equals method, this implementation compares the serialized byte version of the objects.
Gotchas:
get(Object).
This class does not allow null to be used as a key or value.
ConcurrentMap| Modifier and Type | Method and Description |
|---|---|
String |
addEntryListener(EntryListener listener,
boolean includeValue)
Deprecated.
use
addEntryListener(MapListener, boolean) instead. |
String |
addEntryListener(EntryListener listener,
K key,
boolean includeValue)
Deprecated.
|
String |
addEntryListener(EntryListener listener,
Predicate<K,V> predicate,
boolean includeValue)
Deprecated.
use
addEntryListener(MapListener, Predicate, boolean) instead. |
String |
addEntryListener(EntryListener listener,
Predicate<K,V> predicate,
K key,
boolean includeValue)
Deprecated.
|
String |
addEntryListener(MapListener listener,
boolean includeValue)
Adds a
MapListener for this map. |
String |
addEntryListener(MapListener listener,
K key,
boolean includeValue)
Adds a
MapListener for this map. |
String |
addEntryListener(MapListener listener,
Predicate<K,V> predicate,
boolean includeValue)
Adds a
MapListener for this map. |
String |
addEntryListener(MapListener listener,
Predicate<K,V> predicate,
K key,
boolean includeValue)
Adds a
MapListener for this map. |
void |
addIndex(String attribute,
boolean ordered)
Adds an index to this map for the specified entries so
that queries can run faster.
|
String |
addInterceptor(MapInterceptor interceptor)
Adds an interceptor for this map.
|
String |
addLocalEntryListener(EntryListener listener)
Deprecated.
use
addLocalEntryListener(MapListener) instead. |
String |
addLocalEntryListener(EntryListener listener,
Predicate<K,V> predicate,
boolean includeValue)
|
String |
addLocalEntryListener(EntryListener listener,
Predicate<K,V> predicate,
K key,
boolean includeValue)
Deprecated.
|
String |
addLocalEntryListener(MapListener listener)
Adds a
MapListener for this map. |
String |
addLocalEntryListener(MapListener listener,
Predicate<K,V> predicate,
boolean includeValue)
Adds a
MapListener for this map. |
String |
addLocalEntryListener(MapListener listener,
Predicate<K,V> predicate,
K key,
boolean includeValue)
Adds a local entry listener for this map.
|
String |
addPartitionLostListener(MapPartitionLostListener listener)
Adds a MapPartitionLostListener.
|
<SuppliedValue,Result> |
aggregate(Supplier<K,V,SuppliedValue> supplier,
Aggregation<K,SuppliedValue,Result> aggregation)
Executes a predefined aggregation on the maps data set.
|
<SuppliedValue,Result> |
aggregate(Supplier<K,V,SuppliedValue> supplier,
Aggregation<K,SuppliedValue,Result> aggregation,
JobTracker jobTracker)
Executes a predefined aggregation on the maps data set.
|
void |
clear()
This method clears the map and invokes
MapStore.deleteAll(java.util.CollectiondeleteAll on MapStore which,
if connected to a database, will delete the records from that database. |
boolean |
containsKey(Object key)
Returns
true if this map contains an entry for the specified
key. |
boolean |
containsValue(Object value) |
void |
delete(Object key)
Removes the mapping for a key from this map if it is present
(optional operation).
|
Set<Map.Entry<K,V>> |
entrySet()
Returns a
Set clone of the mappings contained in this map. |
Set<Map.Entry<K,V>> |
entrySet(Predicate predicate)
Queries the map based on the specified predicate and
returns the matching entries.
|
boolean |
evict(K key)
Evicts the specified key from this map.
|
void |
evictAll()
Evicts all keys from this map except the locked ones.
|
Map<K,Object> |
executeOnEntries(EntryProcessor entryProcessor)
Applies the user defined EntryProcessor to the all entries in the map.
|
Map<K,Object> |
executeOnEntries(EntryProcessor entryProcessor,
Predicate predicate)
Applies the user defined EntryProcessor to the entries in the map which satisfies provided predicate.
|
Object |
executeOnKey(K key,
EntryProcessor entryProcessor)
Applies the user defined EntryProcessor to the entry mapped by the key.
|
Map<K,Object> |
executeOnKeys(Set<K> keys,
EntryProcessor entryProcessor)
Applies the user defined EntryProcessor to the entries mapped by the collection of keys.
|
void |
flush()
If this map has a MapStore, this method flushes
all the local dirty entries by calling MapStore.storeAll() and/or MapStore.deleteAll().
|
void |
forceUnlock(K key)
Releases the lock for the specified key regardless of the lock owner.
|
V |
get(Object key)
Returns the value for the specified key, or
null if this map does not contain this key. |
Map<K,V> |
getAll(Set<K> keys)
Returns the entries for the given keys.
|
Future<V> |
getAsync(K key)
Asynchronously gets the given key.
|
EntryView<K,V> |
getEntryView(K key)
Returns the EntryView for the specified key.
|
LocalMapStats |
getLocalMapStats()
Returns LocalMapStats for this map.
|
boolean |
isLocked(K key)
Checks the lock for the specified key.
|
Set<K> |
keySet()
Returns a set clone of the keys contained in this map.
|
Set<K> |
keySet(Predicate predicate)
Queries the map based on the specified predicate and
returns the keys of matching entries.
|
void |
loadAll(boolean replaceExistingValues)
Loads all keys into the store.
|
void |
loadAll(Set<K> keys,
boolean replaceExistingValues)
Loads the given keys.
|
Set<K> |
localKeySet()
Returns the locally owned set of keys.
|
Set<K> |
localKeySet(Predicate predicate)
Returns the keys of matching locally owned entries.
|
void |
lock(K key)
Acquires the lock for the specified key.
|
void |
lock(K key,
long leaseTime,
TimeUnit timeUnit)
Acquires the lock for the specified key for the specified lease time.
|
V |
put(K key,
V value)
Associates the specified value with the specified key in this map.
|
V |
put(K key,
V value,
long ttl,
TimeUnit timeunit)
Puts an entry into this map with a given ttl (time to live) value.
|
Future<V> |
putAsync(K key,
V value)
Asynchronously puts the given key and value.
|
Future<V> |
putAsync(K key,
V value,
long ttl,
TimeUnit timeunit)
Asynchronously puts the given key and value into this map with a given ttl (time to live) value.
|
V |
putIfAbsent(K key,
V value)
If the specified key is not already associated
with a value, associate it with the given value.
|
V |
putIfAbsent(K key,
V value,
long ttl,
TimeUnit timeunit)
Puts an entry into this map with a given ttl (time to live) value
if the specified key is not already associated with a value.
|
void |
putTransient(K key,
V value,
long ttl,
TimeUnit timeunit)
Same as
#put(K, V, long, java.util.concurrent.TimeUnit) except that MapStore, if defined,
will not be called to store/persist the entry. |
V |
remove(Object key)
Removes the mapping for a key from this map if it is present.
|
boolean |
remove(Object key,
Object value)
Removes the entry for a key only if currently mapped to a given value.
|
Future<V> |
removeAsync(K key)
Asynchronously removes the given key.
|
boolean |
removeEntryListener(String id)
Removes the specified entry listener.
|
void |
removeInterceptor(String id)
Removes the given interceptor for this map so it will not intercept operations anymore.
|
boolean |
removePartitionLostListener(String id)
Removes the specified map partition lost listener.
|
V |
replace(K key,
V value)
Replaces the entry for a key only if it is currently mapped to some value.
|
boolean |
replace(K key,
V oldValue,
V newValue)
Replaces the entry for a key only if currently mapped to a given value.
|
void |
set(K key,
V value)
Puts an entry into this map.
|
void |
set(K key,
V value,
long ttl,
TimeUnit timeunit)
Puts an entry into this map with a given ttl (time to live) value.
|
Future |
submitToKey(K key,
EntryProcessor entryProcessor)
Applies the user defined EntryProcessor to the entry mapped by the key.
|
void |
submitToKey(K key,
EntryProcessor entryProcessor,
ExecutionCallback callback)
Applies the user defined EntryProcessor to the entry mapped by the key with
specified ExecutionCallback to listen event status and returns immediately.
|
boolean |
tryLock(K key)
Tries to acquire the lock for the specified key.
|
boolean |
tryLock(K key,
long time,
TimeUnit timeunit)
Tries to acquire the lock for the specified key.
|
boolean |
tryPut(K key,
V value,
long timeout,
TimeUnit timeunit)
Tries to put the given key and value into this map within a specified
timeout value.
|
boolean |
tryRemove(K key,
long timeout,
TimeUnit timeunit)
Tries to remove the entry with the given key from this map
within the specified timeout value.
|
void |
unlock(K key)
Releases the lock for the specified key.
|
Collection<V> |
values()
Returns a collection clone of the values contained in this map.
|
Collection<V> |
values(Predicate predicate)
Queries the map based on the specified predicate and
returns the values of matching entries.
|
destroy, getId, getName, getPartitionKey, getServiceNameboolean containsKey(Object key)
true if this map contains an entry for the specified
key.
Warning:
ˆ
This method uses hashCode and equals of the binary form of
the key, not the actual implementations of hashCode and equals
defined in the key's class. The key will first be searched for in memory. If the key is not
found, and if a key is attributed, a MapLoader will then attempt to load the key.
containsKey in interface BaseMap<K,V>containsKey in interface Map<K,V>key - The specified key.true if this map contains an entry for the specified key.NullPointerException - if the specified key is null.boolean containsValue(Object value)
containsValue in interface Map<K,V>NullPointerException - if the specified value is null.V get(Object key)
null if this map does not contain this key.
Warning:
This method returns a clone of the original value, so modifying the returned value does not change the actual value in the map. You should put the modified value back to make changes visible to all nodes.
V value = map.get(key);
value.updateSomeProperty();
map.put(key, value);
Warning-2:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.V put(K key, V value)
Warning:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Warning-2:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.put in interface BaseMap<K,V>put in interface Map<K,V>key - The specified key.value - The value to associate with the key.key or null
if there was no mapping for key.NullPointerException - if the specified key or value is null.V remove(Object key)
The map will not contain a mapping for the specified key once the call returns.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
Warning-2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
boolean remove(Object key, Object value)
if (map.containsKey(key) && map.get(key).equals(value)) {
map.remove(key);
return true;
} else return false;
except that the action is performed atomically.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.remove in interface BaseMap<K,V>remove in interface ConcurrentMap<K,V>key - The specified key.value - Remove the key if it has this value.true if the value was removed.NullPointerException - if the specified key or value is null.void delete(Object key)
Unlike remove(Object), this operation does not return
the removed value, which avoids the serialization cost of the returned value.
The map will not contain a mapping for the specified key once the call returns.
Warning:
This method breaks the contract of EntryListener. When an entry is removed by delete(), it fires an EntryEvent with a null oldValue. Also, a listener with predicates will have null values, so only keys can be queried via predicates.delete in interface BaseMap<K,V>key - key whose mapping is to be removed from the map.ClassCastException - if the key is of an inappropriate type for
this map (optional).NullPointerException - if the specified key is null.void flush()
Map<K,V> getAll(Set<K> keys)
MapLoader.loadAll(java.util.Collection).
Warning:
The returned map is NOT backed by the original map, so changes to the original map are NOT reflected in the returned map, and vice-versa.Warning-2:
This method uses hashCode and equals of the binary form of the keys, not the actual implementations of hashCode and equals defined in the key's class.keys - keys to get.NullPointerException - if any of the specified keys are null.void loadAll(boolean replaceExistingValues)
replaceExistingValues - when true, existing values in the Map will
be replaced by those loaded from the MapLoader
void loadAll(boolean replaceExistingValues));void loadAll(Set<K> keys, boolean replaceExistingValues)
keys - keys of the values entries to load.replaceExistingValues - when true, existing values in the Map will
be replaced by those loaded from the MapLoader.void clear()
MapStore.deleteAll(java.util.Collection) deleteAll on MapStore which,
if connected to a database, will delete the records from that database.
The MAP_CLEARED event is fired for any registered listeners.
See MapClearedListener.mapCleared(MapEvent).
To clear a map without calling MapStore.deleteAll(java.util.Collection) , use evictAll().clear in interface Map<K,V>evictAll()Future<V> getAsync(K key)
Future future = map.getAsync(key);
// do some other stuff, when ready get the result.
Object value = future.get();
Future.get() will block until the actual map.get() completes.
If the application requires timely response,
then Future.get(timeout, timeunit) can be used.
try{
Future future = map.getAsync(key);
Object value = future.get(40, TimeUnit.MILLISECOND);
}catch (TimeoutException t) {
// time wasn't enough
}
ExecutionException is never thrown.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the key of the map entry.NullPointerException - if the specified key is null.FutureFuture<V> putAsync(K key, V value)
Future future = map.putAsync(key, value);
// do some other stuff, when ready get the result.
Object oldValue = future.get();
Future.get() will block until the actual map.put() completes.
If the application requires a timely response,
then you can use Future.get(timeout, timeunit).
try{
Future future = map.putAsync(key, newValue);
Object oldValue = future.get(40, TimeUnit.MILLISECOND);
}catch (TimeoutException t) {
// time wasn't enough
}
ExecutionException is never thrown.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the key of the map entry.value - the new value of the map entry.NullPointerException - if the specified key or value is null.FutureFuture<V> putAsync(K key, V value, long ttl, TimeUnit timeunit)
Future future = map.putAsync(key, value, ttl, timeunit);
// do some other stuff, when ready get the result
Object oldValue = future.get();
Future.get() will block until the actual map.get() completes.
If your application requires a timely response,
then you can use Future.get(timeout, timeunit).
try{
Future future = map.putAsync(key, newValue, ttl, timeunit);
Object oldValue = future.get(40, TimeUnit.MILLISECOND);
}catch (TimeoutException t) {
// time wasn't enough
}
ExecutionException is never thrown.
Warning 1:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.key - the key of the map entry.value - the new value of the map entry.ttl - maximum time for this entry to stay in the map.
0 means infinite.timeunit - time unit for the ttl.NullPointerException - if the specified key or value is null.FutureFuture<V> removeAsync(K key)
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - The key of the map entry to remove.Future from which the value
removed from the map can be retrieved.NullPointerException - if the specified key is null.boolean tryRemove(K key, long timeout, TimeUnit timeunit)
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.Warning-2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
key - key of the entry.timeout - maximum time to wait for acquiring the lock
for the key.timeunit - time unit for the timeout.NullPointerException - if the specified key is null.boolean tryPut(K key, V value, long timeout, TimeUnit timeunit)
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - key of the entry.value - value of the entry.timeout - maximum time to wait.timeunit - time unit for the timeout.NullPointerException - if the specified key or value is null.V put(K key, V value, long ttl, TimeUnit timeunit)
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.Warning-2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Warning 3:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.key - key of the entryvalue - value of the entryttl - maximum time for this entry to stay in the map
0 means infinite.timeunit - time unit for the ttlNullPointerException - if the specified key or value is nullvoid putTransient(K key, V value, long ttl, TimeUnit timeunit)
#put(K, V, long, java.util.concurrent.TimeUnit) except that MapStore, if defined,
will not be called to store/persist the entry. If ttl is 0, then
the entry lives forever.
Warning 1:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to next closest second value.key - key of the entryvalue - value of the entryttl - maximum time for this entry to stay in the map.
0 means infinite.timeunit - time unit for the ttlNullPointerException - if the specified key or value is nullV putIfAbsent(K key, V value)
if (!map.containsKey(key))
return map.put(key, value);
else
return map.get(key);
except that the action is performed atomically.
Note:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.Also, this method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
putIfAbsent in interface BaseMap<K,V>putIfAbsent in interface ConcurrentMap<K,V>key - The specified key.value - The value to associate with the key when there is no previous value.NullPointerException - if the specified key or value is null.V putIfAbsent(K key, V value, long ttl, TimeUnit timeunit)
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.Warning-2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Warning 3:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.key - key of the entry.value - value of the entry.ttl - maximum time for this entry to stay in the map.timeunit - time unit for the ttl.NullPointerException - if the specified key or value is null.boolean replace(K key, V oldValue, V newValue)
if (map.containsKey(key) && map.get(key).equals(oldValue)) {
map.put(key, newValue);
return true;
} else return false;
except that the action is performed atomically.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.replace in interface BaseMap<K,V>replace in interface ConcurrentMap<K,V>key - The specified key.oldValue - Replace the key value if it is the old value.newValue - The new value to replace the old value.true if the value was replaced.NullPointerException - if any of the specified parameters are null.V replace(K key, V value)
if (map.containsKey(key)) {
return map.put(key, value);
} else return null;
except that the action is performed atomically.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.Warning-2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
replace in interface BaseMap<K,V>replace in interface ConcurrentMap<K,V>key - The specified key.value - The value to replace the previous value.key, or null
if there was no mapping for key.NullPointerException - if the specified key or value is null.void set(K key, V value)
Warning:
This method breaks the contract of EntryListener. When an entry is updated by set(), it fires an EntryEvent with a null oldValue.Warning-2:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.set in interface BaseMap<K,V>key - key of the entry.value - value of the entry.NullPointerException - if the specified key or value is null.void set(K key, V value, long ttl, TimeUnit timeunit)
Warning 1:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.key - key of the entryvalue - value of the entryttl - maximum time for this entry to stay in the map
0 means infinite.timeunit - time unit for the ttlNullPointerException - if the specified key or value is nullvoid lock(K key)
If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.
You get a lock whether the value is present in the map or not. Other threads (possibly on other systems) would block on their invoke oflock() until the non-existent key is unlocked. If the lock
holder introduces the key to the map, the put() operation
is not blocked. If a thread not holding a lock on the non-existent key
tries to introduce the key while a lock exists on the non-existent key,
the put() operation blocks until it is unlocked.
Scope of the lock is this map only.
Acquired lock is only for the key in this map.
Locks are re-entrant so if the key is locked N times then
it should be unlocked N times before another thread can acquire it.
There is no lock timeout on this method. Locks will be held infinitely.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - key to lock.NullPointerException - if the specified key is null.void lock(K key, long leaseTime, TimeUnit timeUnit)
After lease time, the lock will be released.
If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.
Scope of the lock is this map only. Acquired lock is only for the key in this map. Locks are re-entrant, so if the key is locked N times then it should be unlocked N times before another thread can acquire it.Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the key to lock.leaseTime - time to wait before releasing the lock.timeUnit - unit of time to specify lease time.NullPointerException - if the specified key is null.boolean isLocked(K key)
If the lock is acquired then returns true, else returns false.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the key that is checked for lock.NullPointerException - if the specified key is null.boolean tryLock(K key)
If the lock is not available then the current thread doesn't wait and returns false immediately.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the key to lock.NullPointerException - if the specified key is null.boolean tryLock(K key, long time, TimeUnit timeunit) throws InterruptedException
If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happens:
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - key to lock in this map.time - maximum time to wait for the lock.timeunit - time unit of the time argument.NullPointerException - if the specified key is null.InterruptedExceptionvoid unlock(K key)
If the current thread is the holder of this lock, then the hold
count is decremented. If the hold count is zero, then the lock
is released. If the current thread is not the holder of this
lock, then IllegalMonitorStateException is thrown.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the key to lock.NullPointerException - if the specified key is null.IllegalMonitorStateException - if the current thread does not hold this lock.void forceUnlock(K key)
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the key to lock.NullPointerException - if the specified key is null.String addLocalEntryListener(MapListener listener)
MapListener for this map. To receive an event, you should
implement a corresponding MapListener sub-interface for that event.
Note that entries in distributed map are partitioned across
the cluster members; each member owns and manages the some portion of the
entries. Owned entries are called local entries. This
listener will be listening for the events of local entries. Let's say
your cluster has member1 and member2. On member2 you added a local listener and from
member1, you call map.put(key2, value2).
If the key2 is owned by member2 then the local listener will be
notified for the add/update event. Also note that entries can migrate to
other nodes for load balancing and/or membership change.listener - MapListener for this map.localKeySet(),
MapListenerString addLocalEntryListener(EntryListener listener)
addLocalEntryListener(MapListener) instead.map.put(key2, value2).
If the key2 is owned by member2 then the local listener will be
notified for the add/update event. Also note that entries can migrate to
other nodes for load balancing and/or membership change.listener - entry listener.localKeySet()String addLocalEntryListener(MapListener listener, Predicate<K,V> predicate, boolean includeValue)
MapListener for this map. To receive an event, you should
implement a corresponding MapListener sub-interface for that event.
Listener will get notified for map events filtered by the given predicate.listener - MapListener for this map.predicate - predicate for filtering entriesincludeValue - true if EntryEvent should
contain the value.MapListenerString addLocalEntryListener(EntryListener listener, Predicate<K,V> predicate, boolean includeValue)
listener - entry listenerpredicate - predicate for filtering entriesincludeValue - true if EntryEvent should
contain the value.String addLocalEntryListener(MapListener listener, Predicate<K,V> predicate, K key, boolean includeValue)
listener - MapListener for this map.predicate - predicate for filtering entries.key - key to listen for.includeValue - true if EntryEvent should
contain the value.MapListenerString addLocalEntryListener(EntryListener listener, Predicate<K,V> predicate, K key, boolean includeValue)
addLocalEntryListener(MapListener, com.hazelcast.query.Predicate, boolean) insteadlistener - entry listener.predicate - predicate for filtering entries.key - key to listen for.includeValue - true if EntryEvent should
contain the value.String addInterceptor(MapInterceptor interceptor)
interceptor - map interceptor.void removeInterceptor(String id)
id - registration id of the map interceptor.String addEntryListener(MapListener listener, boolean includeValue)
MapListener for this map. To receive an event, you should
implement a corresponding MapListener sub-interface for that event.listener - MapListener for this map.includeValue - true if EntryEvent should
contain the value.MapListenerString addEntryListener(EntryListener listener, boolean includeValue)
addEntryListener(MapListener, boolean) instead.listener - the added entry listener for this map.includeValue - true if EntryEvent should
contain the value.boolean removeEntryListener(String id)
id - id of registered listener.String addPartitionLostListener(MapPartitionLostListener listener)
removePartitionLostListener(String) method.
There is no check for duplicate registrations, so if you register the listener twice, it will get events twice.
IMPORTANT: Please @see com.hazelcast.partition.PartitionLostListener for weaknesses.
IMPORTANT: Listeners registered from HazelcastClient may miss some of the map partition lost events due
to design limitations.listener - the added MapPartitionLostListener.NullPointerException - if listener is null.removePartitionLostListener(String)boolean removePartitionLostListener(String id)
id - id of registered listener.String addEntryListener(MapListener listener, K key, boolean includeValue)
MapListener for this map. To receive an event, you should
implement a corresponding MapListener sub-interface for that event.
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.listener - MapListener for this map.key - key to listen for.includeValue - true if EntryEvent should
contain the value.NullPointerException - if the specified key is null.MapListenerString addEntryListener(EntryListener listener, K key, boolean includeValue)
addEntryListener(MapListener, Predicate, Object, boolean) instead.Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.listener - specified entry listener.key - key to listen for.includeValue - true if EntryEvent should
contain the value.NullPointerException - if the specified key is null.String addEntryListener(MapListener listener, Predicate<K,V> predicate, boolean includeValue)
MapListener for this map. To receive an event, you should
implement a corresponding MapListener sub-interface for that event.listener - the added continuous MapListener for this map.predicate - predicate for filtering entries.includeValue - true if EntryEvent should
contain the value.MapListenerString addEntryListener(EntryListener listener, Predicate<K,V> predicate, boolean includeValue)
addEntryListener(MapListener, Predicate, boolean) instead.listener - the added continuous entry listener for this map.predicate - predicate for filtering entries.includeValue - true if EntryEvent should
contain the value.String addEntryListener(MapListener listener, Predicate<K,V> predicate, K key, boolean includeValue)
MapListener for this map. To receive an event, you should
implement a corresponding MapListener sub-interface for that event.listener - the continuous MapListener for this map.predicate - predicate for filtering entries.key - key to listen for.includeValue - true if EntryEvent should
contain the value.MapListenerString addEntryListener(EntryListener listener, Predicate<K,V> predicate, K key, boolean includeValue)
addEntryListener(MapListener, Object, boolean)listener - the continuous entry listener for this map.predicate - predicate for filtering entries.key - key to listen for.includeValue - true if EntryEvent should
contain the value.EntryView<K,V> getEntryView(K key)
Warning:
This method returns a clone of original mapping, modifying the returned value does not change the actual value in the map. One should put modified value back to make changes visible to all nodes.
Warning-2:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the key of the entry.NullPointerException - if the specified key is null.EntryViewboolean evict(K key)
Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.key - the specified key to evict from this map.NullPointerException - if the specified key is null.void evictAll()
clear() method.
The EVICT_ALL event is fired for any registered listeners.
See MapEvictedListener.mapEvicted(MapEvent) .clear()Set<K> keySet()
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa. On the server side this method is executed by a distributed query so it may throw aQueryResultSizeExceededException
if GroupProperties.PROP_QUERY_RESULT_SIZE_LIMIT is configured.keySet in interface Map<K,V>QueryResultSizeExceededException - on server side if query result size limit is exceededGroupProperties.PROP_QUERY_RESULT_SIZE_LIMITCollection<V> values()
Warning:
The collection is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa. On the server side this method is executed by a distributed query so it may throw aQueryResultSizeExceededException
if GroupProperties.PROP_QUERY_RESULT_SIZE_LIMIT is configured.values in interface Map<K,V>QueryResultSizeExceededException - on server side if query result size limit is exceededGroupProperties.PROP_QUERY_RESULT_SIZE_LIMITSet<Map.Entry<K,V>> entrySet()
Set clone of the mappings contained in this map.
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa. On the server side this method is executed by a distributed query so it may throw aQueryResultSizeExceededException
if GroupProperties.PROP_QUERY_RESULT_SIZE_LIMIT is configured.entrySet in interface Map<K,V>QueryResultSizeExceededException - on server side if query result size limit is exceededGroupProperties.PROP_QUERY_RESULT_SIZE_LIMITSet<K> keySet(Predicate predicate)
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa. This method is always executed by a distributed query so it may throw aQueryResultSizeExceededException
if GroupProperties.PROP_QUERY_RESULT_SIZE_LIMIT is configured.predicate - specified query criteria.QueryResultSizeExceededException - if query result size limit is exceededGroupProperties.PROP_QUERY_RESULT_SIZE_LIMITSet<Map.Entry<K,V>> entrySet(Predicate predicate)
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa. This method is always executed by a distributed query so it may throw aQueryResultSizeExceededException
if GroupProperties.PROP_QUERY_RESULT_SIZE_LIMIT is configured.predicate - specified query criteria.QueryResultSizeExceededException - if query result size limit is exceededGroupProperties.PROP_QUERY_RESULT_SIZE_LIMITCollection<V> values(Predicate predicate)
Warning:
The collection is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa. This method is always executed by a distributed query so it may throw aQueryResultSizeExceededException
if GroupProperties.PROP_QUERY_RESULT_SIZE_LIMIT is configured.predicate - specified query criteria.QueryResultSizeExceededException - if query result size limit is exceededGroupProperties.PROP_QUERY_RESULT_SIZE_LIMITSet<K> localKeySet()
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa. On the server side this method is executed by a distributed query so it may throw aQueryResultSizeExceededException
if GroupProperties.PROP_QUERY_RESULT_SIZE_LIMIT is configured.QueryResultSizeExceededException - on server side if query result size limit is exceededGroupProperties.PROP_QUERY_RESULT_SIZE_LIMITSet<K> localKeySet(Predicate predicate)
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa. This method is always executed by a distributed query so it may throw aQueryResultSizeExceededException
if GroupProperties.PROP_QUERY_RESULT_SIZE_LIMIT is configured.predicate - specified query criteria.QueryResultSizeExceededException - if query result size limit is exceededGroupProperties.PROP_QUERY_RESULT_SIZE_LIMITvoid addIndex(String attribute, boolean ordered)
public class Employee implements Serializable {
private boolean active = false;
private int age;
private String name = null;
// other fields.
// getters setter
}
If you are querying your values mostly based on age and active then
you should consider indexing these fields.
IMap imap = Hazelcast.getMap("employees");
imap.addIndex("age", true); // ordered, since we have ranged queries for this field
imap.addIndex("active", false); // not ordered, because boolean field cannot have range
Index attribute should either have a getter method or be public.
You should also make sure to add the indexes before adding
entries to this map.
attribute - index attribute of valueordered - true if index should be ordered,
false otherwise.LocalMapStats getLocalMapStats()
Object executeOnKey(K key, EntryProcessor entryProcessor)
NullPointerException - if the specified key is nullMap<K,Object> executeOnKeys(Set<K> keys, EntryProcessor entryProcessor)
NullPointerException - if the specified key is null.void submitToKey(K key, EntryProcessor entryProcessor, ExecutionCallback callback)
key - key to be processed.entryProcessor - processor to process the key.callback - to listen whether operation is finished or not.Future submitToKey(K key, EntryProcessor entryProcessor)
key - key to be processedentryProcessor - processor to process the keyFutureMap<K,Object> executeOnEntries(EntryProcessor entryProcessor)
Map<K,Object> executeOnEntries(EntryProcessor entryProcessor, Predicate predicate)
<SuppliedValue,Result> Result aggregate(Supplier<K,V,SuppliedValue> supplier, Aggregation<K,SuppliedValue,Result> aggregation)
Supplier
is used to either select or to select and extract a (sub-)value. A predefined set of aggregations can be found in
Aggregations.SuppliedValue - the final type emitted from the supplier.Result - the resulting aggregation value type.supplier - the supplier to select and / or extract a (sub-)value from the map.aggregation - the aggregation that is being executed against the map.<SuppliedValue,Result> Result aggregate(Supplier<K,V,SuppliedValue> supplier, Aggregation<K,SuppliedValue,Result> aggregation, JobTracker jobTracker)
Supplier
is used to either select or to select and extract a (sub-)value. A predefined set of aggregations can be found in
Aggregations.SuppliedValue - the final type emitted from the supplier.Result - the resulting aggregation value type.supplier - the supplier to select and / or extract a (sub-)value from the map.aggregation - the aggregation that is being executed against the map.jobTracker - the JobTracker instance to execute the aggregation.Copyright © 2015 Hazelcast, Inc.. All Rights Reserved.