# Interface Bindings

All Superinterfaces:
  `Map<String,Object>`

All Known Implementing Classes:
  `SimpleBindings`

public interface Bindings extends Map<String,Object>
A mapping of key/value pairs, all of whose keys are `Strings`.

Since:
  1.6

## Nested Class Summary

### Nested classes/interfaces declared in interface Map

`Map.Entry<K,V>`
Modifier and Type
Interface
Description
`static interface`
`Map.Entry<K,V>`
A map entry (key-value pair).

## Method Summary

Modifier and Type
Method
Description
`boolean`
`containsKey(Object key)`
Returns `true` if this map contains a mapping for the specified key.
`Object`
`get(Object key)`
Returns the value to which this map maps the specified key.
`Object`
`put(String name, Object value)`
Set a named value.
`void`
`putAll(Map<? extends String, ? extends Object> toMerge)`
Adds all the mappings in a given `Map` to this `Bindings`.
`Object`
`remove(Object key)`
Removes the mapping for this key from this map if it is present (optional operation).

### Methods declared in interface Map

`clear, compute, computeIfAbsent, computeIfPresent, containsValue, entrySet, equals, forEach, getOrDefault, hashCode, isEmpty, keySet, merge, putIfAbsent, remove, replace, replace, replaceAll, size, values`
Modifier and Type
Method
Description
`void`
`clear()`
Removes all of the mappings from this map (optional operation).
`default Object`
`compute(String key, BiFunction<? super String, ? super Object, ? extends Object> remappingFunction)`
Attempts to compute a mapping for the specified key and its current mapped value, or `null` if there is no current mapping (optional operation).
`default Object`
`computeIfAbsent(String key, Function<? super String, ? extends Object> mappingFunction)`
If the specified key is not already associated with a value (or is mapped to `null`), attempts to compute its value using the given mapping function and enters it into this map unless `null` (optional operation).
`default Object`
`computeIfPresent(String key, BiFunction<? super String, ? super Object, ? extends Object> remappingFunction)`
If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value (optional operation).
`boolean`
`containsValue(Object value)`
Returns `true` if this map maps one or more keys to the specified value.
`Set<Map.Entry<String,Object>>`
`entrySet()`
Returns a `Set` view of the mappings contained in this map.
`boolean`
`equals(Object o)`
Compares the specified object with this map for equality.
`default void`
`forEach(BiConsumer<? super String, ? super Object> action)`
Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
`default Object`
`getOrDefault(Object key, Object defaultValue)`
Returns the value to which the specified key is mapped, or `defaultValue` if this map contains no mapping for the key.
`int`
`hashCode()`
Returns the hash code value for this map.
`boolean`
`isEmpty()`
Returns `true` if this map contains no key-value mappings.
`Set<String>`
`keySet()`
Returns a `Set` view of the keys contained in this map.
`default Object`
`merge(String key, Object value, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction)`
If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value (optional operation).
`default Object`
`putIfAbsent(String key, Object value)`
If the specified key is not already associated with a value (or is mapped to `null`) associates it with the given value and returns `null`, else returns the current value (optional operation).
`default boolean`
`remove(Object key, Object value)`
Removes the entry for the specified key only if it is currently mapped to the specified value (optional operation).
`default Object`
`replace(String key, Object value)`
Replaces the entry for the specified key only if it is currently mapped to some value (optional operation).
`default boolean`
`replace(String key, Object oldValue, Object newValue)`
Replaces the entry for the specified key only if currently mapped to the specified value (optional operation).
`default void`
`replaceAll(BiFunction<? super String, ? super Object, ? extends Object> function)`
Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception (optional operation).
`int`
`size()`
Returns the number of key-value mappings in this map.
`Collection<Object>`
`values()`
Returns a `Collection` view of the values contained in this map.

## Method Details

### put

Object put(String name, Object value)
Set a named value.

Specified by:
  `put` in interface `Map<String,Object>`
Parameters:
  `name` - The name associated with the value.
  `value` - The value associated with the name.
Returns:
  The value previously associated with the given name. Returns null if no value was previously associated with the name.
Throws:
  `NullPointerException` - if the name is null.
  `IllegalArgumentException` - if the name is empty String.

### putAll

void putAll(Map<? extends String, ? extends Object> toMerge)
Adds all the mappings in a given `Map` to this `Bindings`.

Specified by:
  `putAll` in interface `Map<String,Object>`
Parameters:
  `toMerge` - The `Map` to merge with this one.
Throws:
  `NullPointerException` - if toMerge map is null or if some key in the map is null.
  `IllegalArgumentException` - if some key in the map is an empty String.

### containsKey

boolean containsKey(Object key)
Returns `true` if this map contains a mapping for the specified key. More formally, returns `true` if and only if this map contains a mapping for a key `k` such that `(key==null ? k==null : key.equals(k))`. (There can be at most one such mapping.)

Specified by:
  `containsKey` in interface `Map<String,Object>`
Parameters:
  `key` - key whose presence in this map is to be tested.
Returns:
  `true` if this map contains a mapping for the specified key.
Throws:
  `NullPointerException` - if key is null
  `ClassCastException` - if key is not String
  `IllegalArgumentException` - if key is empty String

### get

Object get(Object key)
Returns the value to which this map maps the specified key. Returns `null` if the map contains no mapping for this key. A return value of `null` does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to `null`. The `containsKey` operation may be used to distinguish these two cases.

More formally, if this map contains a mapping from a key `k` to a value `v` such that `(key==null ? k==null : key.equals(k))`, then this method returns `v`; otherwise it returns `null`. (There can be at most one such mapping.)

Specified by:
  `get` in interface `Map<String,Object>`
Parameters:
  `key` - key whose associated value is to be returned.
Returns:
  the value to which this map maps the specified key, or `null` if the map contains no mapping for this key.
Throws:
  `NullPointerException` - if key is null
  `ClassCastException` - if key is not String
  `IllegalArgumentException` - if key is empty String

### remove

Object remove(Object key)
Removes the mapping for this key from this map if it is present (optional operation). More formally, if this map contains a mapping from key `k` to value `v` such that `(key==null ? k==null : key.equals(k))`, that mapping is removed. (The map can contain at most one such mapping.)

Returns the value to which the map previously associated the key, or `null` if the map contained no mapping for this key. (A `null` return can also indicate that the map previously associated `null` with the specified key if the implementation supports `null` values.) The map will not contain a mapping for the specified key once the call returns.

Specified by:
  `remove` in interface `Map<String,Object>`
Parameters:
  `key` - key whose mapping is to be removed from the map.
Returns:
  previous value associated with specified key, or `null` if there was no mapping for key.
Throws:
  `NullPointerException` - if key is null
  `ClassCastException` - if key is not String
  `IllegalArgumentException` - if key is empty String