| boolean | IgniteCache. containsKey(K key) | 
| IgniteFuture<Boolean> | IgniteCache. containsKeyAsync(K key) | Asynchronously determines if the Cachecontains an entry for the specified key. | 
| boolean | IgniteCache. containsKeys(Set<? extends K> keys) | Determines if the Cachecontains entries for the specified keys. | 
| IgniteFuture<Boolean> | IgniteCache. containsKeysAsync(Set<? extends K> keys) | Asynchronously determines if the Cachecontains entries for the specified keys. | 
| V | IgniteCache. get(K key) | 
| Map<K,V> | IgniteCache. getAll(Set<? extends K> keys) | 
| IgniteFuture<Map<K,V>> | IgniteCache. getAllAsync(Set<? extends K> keys) | Asynchronously gets a collection of entries from the  Cache, returning them as
  Map of the values associated with the set of keys requested. | 
| V | IgniteCache. getAndPut(K key,
         V val) | 
| IgniteFuture<V> | IgniteCache. getAndPutAsync(K key,
              V val) | Asynchronously associates the specified value with the specified key in this cache,
 returning an existing value if one existed as the future result. | 
| V | IgniteCache. getAndPutIfAbsent(K key,
                 V val) | Stores given key-value pair in cache only if cache had no previous mapping for it. | 
| IgniteFuture<V> | IgniteCache. getAndPutIfAbsentAsync(K key,
                      V val) | Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it. | 
| V | IgniteCache. getAndRemove(K key) | 
| IgniteFuture<V> | IgniteCache. getAndRemoveAsync(K key) | Asynchronously removes the entry for a key only if currently mapped to some
 value. | 
| V | IgniteCache. getAndReplace(K key,
             V val) | 
| Collection<CacheEntry<K,V>> | IgniteCache. getEntries(Set<? extends K> keys) | Gets a collection of entries from the Cache. | 
| IgniteFuture<Collection<CacheEntry<K,V>>> | IgniteCache. getEntriesAsync(Set<? extends K> keys) | Asynchronously gets a collection of entries from the Cache. | 
| CacheEntry<K,V> | IgniteCache. getEntry(K key) | Gets an entry from the cache. | 
| IgniteFuture<CacheEntry<K,V>> | IgniteCache. getEntryAsync(K key) | Asynchronously gets an entry from the cache. | 
| <T> T | IgniteCache. invoke(K key,
      javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
      Object... arguments) | 
| <T> T | IgniteCache. invoke(K key,
      CacheEntryProcessor<K,V,T> entryProcessor,
      Object... arguments) |  | 
| <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> | IgniteCache. invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
         Object... args) | Asynchronously invokes each EntryProcessorfrom map's values against the correspondentCache.Entryspecified by map's key set. | 
| <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> | IgniteCache. invokeAll(Set<? extends K> keys,
         javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
         Object... args) | 
| <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> | IgniteCache. invokeAll(Set<? extends K> keys,
         CacheEntryProcessor<K,V,T> entryProcessor,
         Object... args) |  | 
| <T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> | IgniteCache. invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
              Object... args) |  | 
| <T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> | IgniteCache. invokeAllAsync(Set<? extends K> keys,
              javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
              Object... args) | Asynchronously invokes an EntryProcessoragainst the set ofCache.Entrys
 specified by the set of keys. | 
| <T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> | IgniteCache. invokeAllAsync(Set<? extends K> keys,
              CacheEntryProcessor<K,V,T> entryProcessor,
              Object... args) | Asynchronously invokes an  CacheEntryProcessor against the set of  Cache.Entrys
 specified by the set of keys. | 
| <T> IgniteFuture<T> | IgniteCache. invokeAsync(K key,
           javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
           Object... arguments) | Asynchronously invokes an EntryProcessoragainst theCache.Entryspecified by
 the provided key. | 
| <T> IgniteFuture<T> | IgniteCache. invokeAsync(K key,
           CacheEntryProcessor<K,V,T> entryProcessor,
           Object... arguments) | Asynchronously invokes an  CacheEntryProcessor against the  Cache.Entry specified by
 the provided key. | 
| void | IgniteCache. put(K key,
   V val) | 
| void | IgniteCache. putAll(Map<? extends K,? extends V> map) | 
| IgniteFuture<Void> | IgniteCache. putAllAsync(Map<? extends K,? extends V> map) | Asynchronously copies all of the entries from the specified map to the Cache. | 
| IgniteFuture<Void> | IgniteCache. putAsync(K key,
        V val) | Asynchronously associates the specified value with the specified key in the cache. | 
| boolean | IgniteCache. putIfAbsent(K key,
           V val) | 
| boolean | IgniteCache. remove(K key) | 
| boolean | IgniteCache. remove(K key,
      V oldVal) | 
| void | IgniteCache. removeAll(Set<? extends K> keys) | 
| IgniteFuture<Void> | IgniteCache. removeAllAsync(Set<? extends K> keys) | Asynchronously removes entries for the specified keys. | 
| IgniteFuture<Boolean> | IgniteCache. removeAsync(K key) | Asynchronously removes the mapping for a key from this cache if it is present. | 
| IgniteFuture<Boolean> | IgniteCache. removeAsync(K key,
           V oldVal) | Asynchronously removes the mapping for a key only if currently mapped to the
 given value. | 
| boolean | IgniteCache. replace(K key,
       V val) | 
| boolean | IgniteCache. replace(K key,
       V oldVal,
       V newVal) | 
| IgniteFuture<Boolean> | IgniteCache. replaceAsync(K key,
            V val) | Asynchronously replaces the entry for a key only if currently mapped to a
 given value. | 
| IgniteFuture<Boolean> | IgniteCache. replaceAsync(K key,
            V oldVal,
            V newVal) |  |