Jetty :: Utilities 7.0.0.pre5 · org.mortbay.util.MultiMap

Modifier and Type	Field and Description
pack-priv ConcurrentMap<K, Object>	_cmap
pack-priv Map<K, Object>	_map

Access	Constructor and Description
public	MultiMap()
public	MultiMap(Map<K, V> map)
public	MultiMap(int capacity)
public	MultiMap(boolean concurrent)

Method Summary

Modifier and Type	Method and Description
public void	add(K The entry key. name, Object The entry value. value) Add value to multi valued entry.
public void	addValues(K The entry key. name, List<E> The List of multiple values. values) Add values to multi valued entry.
public void	addValues(K The entry key. name, String[] The String array of multiple values. values) Add values to multi valued entry.
public void	clear() Implements java.util.Map.clear. Removes all of the mappings from this map (optional operation).
public boolean	containsKey(Object key whose presence in this map is to be tested key) Implements java.util.Map.containsKey. Returns `true` if this map contains a mapping for the specified key.
public boolean	containsValue(Object value whose presence in this map is to be tested value) Implements java.util.Map.containsValue. Returns `true` if this map maps one or more keys to the specified value.
public Set<Map.Entry<K, Object>>	entrySet() Implements java.util.Map.entrySet. Returns a `Set` view of the mappings contained in this map.
public boolean	equals(Object object to be compared for equality with this map o) Overrides java.lang.Object.equals. Implements java.util.Map.equals. Compares the specified object with this map for equality.
public Object	get(Object the key whose associated value is to be returned name) Implements java.util.Map.get. Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.
public String	Returns: String value. getString(Object The entry key. name) Get value as String.
public Object	Returns: Unmodifieable List of values. getValue(Object The entry key. name, int Index of element to get. i) Get a value from a multiple value.
public List<E>	Returns: Unmodifieable List of values. getValues(Object The entry key. name) Get multiple values.
public int	hashCode() Overrides java.lang.Object.hashCode. Implements java.util.Map.hashCode. Returns the hash code value for this map.
public boolean	isEmpty() Implements java.util.Map.isEmpty. Returns `true` if this map contains no key-value mappings.
public Set<K>	keySet() Implements java.util.Map.keySet. Returns a `Set` view of the keys contained in this map.
public Object	Returns: The previous value or null. put(K The entry key. name, Object The entry value. value) Implements java.util.Map.put. Put and entry into the map.
public void	putAll(Map<K, V> Map m) Implements java.util.Map.putAll. Put all contents of map.
public Object	putIfAbsent(K key with which the specified value is to be associated key, Object value to be associated with the specified key value) Implements java.util.concurrent.ConcurrentMap.putIfAbsent. If the specified key is not already associated with a value, associates it with the given value.
public Object	Returns: The previous value or null. putValues(K The entry key. name, List<E> The List of multiple values. values) Put multi valued entry.
public Object	Returns: The previous value or null. putValues(K The entry key. name, String[] The String array of multiple values. values) Put multi valued entry.
public Object	remove(Object key whose mapping is to be removed from the map key) Implements java.util.Map.remove. Removes the mapping for a key from this map if it is present (optional operation).
public boolean	remove(Object key with which the specified value is associated key, Object value expected to be associated with the specified key value) Implements java.util.concurrent.ConcurrentMap.remove. Removes the entry for a key only if currently mapped to a given value.
public boolean	Returns: true if it was removed. removeValue(K The entry key. name, Object The entry value. value) Remove value.
public boolean	replace(K key with which the specified value is associated key, Object value expected to be associated with the specified key oldValue, Object value to be associated with the specified key newValue) Implements java.util.concurrent.ConcurrentMap.replace. Replaces the entry for a key only if currently mapped to a given value.
public Object	replace(K key with which the specified value is associated key, Object value to be associated with the specified key value) Implements java.util.concurrent.ConcurrentMap.replace. Replaces the entry for a key only if currently mapped to some value.
public int	size() Implements java.util.Map.size. Returns the number of key-value mappings in this map.
public Map<K, V>	Returns: Map of String arrays toStringArrayMap()
public Collection<Object>	values() Implements java.util.Map.values. Returns a `Collection` view of the values contained in this map.

Inherited from java.lang.Object:: clone finalize getClass notify notifyAll toString wait wait wait

_cmap	back to summary
pack-priv ConcurrentMap<K, Object> _cmap

_map	back to summary
pack-priv Map<K, Object> _map

MultiMap	back to summary
public MultiMap()

MultiMap	back to summary
public MultiMap(Map<K, V> map)

MultiMap	back to summary
public MultiMap(int capacity)

MultiMap	back to summary
public MultiMap(boolean concurrent)

Method Detail

add	back to summary
public void add(K name, Object value) Add value to multi valued entry. If the entry is single valued, it is converted to the first value of a multi valued entry. Parameters name:K The entry key. value:Object The entry value.

add

back to summary

public void add(K name, Object value)

Add value to multi valued entry. If the entry is single valued, it is converted to the first value of a multi valued entry.

Parameters

name:K: The entry key.
value:Object: The entry value.

addValues	back to summary
public void addValues(K name, List<E> values) Add values to multi valued entry. If the entry is single valued, it is converted to the first value of a multi valued entry. Parameters name:K The entry key. values:List<E> The List of multiple values.

addValues

back to summary

public void addValues(K name, List<E> values)

Add values to multi valued entry. If the entry is single valued, it is converted to the first value of a multi valued entry.

Parameters

name:K: The entry key.
values:List<E>: The List of multiple values.

addValues	back to summary
public void addValues(K name, String[] values) Add values to multi valued entry. If the entry is single valued, it is converted to the first value of a multi valued entry. Parameters name:K The entry key. values:String[] The String array of multiple values.

addValues

back to summary

public void addValues(K name, String[] values)

Add values to multi valued entry. If the entry is single valued, it is converted to the first value of a multi valued entry.

Parameters

name:K: The entry key.
values:String[]: The String array of multiple values.

clear	back to summary
public void clear() Implements java.util.Map.clear. Doc from java.util.Map.clear. Removes all of the mappings from this map (optional operation). The map will be empty after this call returns.

clear

back to summary

public void clear()

Implements java.util.Map.clear.

Doc from java.util.Map.clear.

Removes all of the mappings from this map (optional operation). The map will be empty after this call returns.

containsKey back to summary

containsKey	back to summary
public boolean containsKey(Object key) Implements java.util.Map.containsKey. Doc from java.util.Map.containsKey. 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 `Objects.equals(key, k)`. (There can be at most one such mapping.) Parameters key:Object key whose presence in this map is to be tested Returns:boolean `true` if this map contains a mapping for the specified key

public boolean containsKey(Object key)

Implements java.util.Map.containsKey.

Doc from java.util.Map.containsKey.

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 Objects.equals(key, k). (There can be at most one such mapping.)

Parameters

key:Object: key whose presence in this map is to be tested

Returns:boolean

true if this map contains a mapping for the specified key

containsValue back to summary

containsValue	back to summary
public boolean containsValue(Object value) Implements java.util.Map.containsValue. Doc from java.util.Map.containsValue. Returns `true` if this map maps one or more keys to the specified value. More formally, returns `true` if and only if this map contains at least one mapping to a value `v` such that `Objects.equals(value, v)`. This operation will probably require time linear in the map size for most implementations of the `Map` interface. Parameters value:Object value whose presence in this map is to be tested Returns:boolean `true` if this map maps one or more keys to the specified value

public boolean containsValue(Object value)

Implements java.util.Map.containsValue.

Doc from java.util.Map.containsValue.

Returns true if this map maps one or more keys to the specified value. More formally, returns true if and only if this map contains at least one mapping to a value v such that Objects.equals(value, v). This operation will probably require time linear in the map size for most implementations of the Map interface.

Parameters

value:Object: value whose presence in this map is to be tested

Returns:boolean

true if this map maps one or more keys to the specified value

entrySet back to summary

entrySet	back to summary
public Set<Map.Entry<K, Object>> entrySet() Implements java.util.Map.entrySet. Doc from java.util.Map.entrySet. Returns a `Set` view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation, or through the `setValue` operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations. Returns:Set<Map.Entry<K, Object>> a set view of the mappings contained in this map

public Set<Map.Entry<K, Object>> entrySet()

Implements java.util.Map.entrySet.

Doc from java.util.Map.entrySet.

Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation, or through the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.

Returns:Set<Map.Entry<K, Object>>: a set view of the mappings contained in this map

equals back to summary

equals	back to summary
public boolean equals(Object o) Overrides java.lang.Object.equals. Implements java.util.Map.equals. Doc from java.util.Map.equals. Compares the specified object with this map for equality. Returns `true` if the given object is also a map and the two maps represent the same mappings. More formally, two maps `m1` and `m2` represent the same mappings if `m1.entrySet().equals(m2.entrySet())`. This ensures that the `equals` method works properly across different implementations of the `Map` interface. Parameters o:Object object to be compared for equality with this map Returns:boolean `true` if the specified object is equal to this map

public boolean equals(Object o)

Overrides java.lang.Object.equals.

Implements java.util.Map.equals.

Doc from java.util.Map.equals.

Compares the specified object with this map for equality. Returns true if the given object is also a map and the two maps represent the same mappings. More formally, two maps m1 and m2 represent the same mappings if m1.entrySet().equals(m2.entrySet()). This ensures that the equals method works properly across different implementations of the Map interface.

Parameters

o:Object: object to be compared for equality with this map

Returns:boolean

true if the specified object is equal to this map

get back to summary

get	back to summary
public Object get(Object name) Implements java.util.Map.get. Doc from java.util.Map.get. Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key. More formally, if this map contains a mapping from a key `k` to a value `v` such that `Objects.equals(key, k)`, then this method returns `v`; otherwise it returns `null`. (There can be at most one such mapping.) If this map permits null values, then 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. Parameters name:Object the key whose associated value is to be returned Returns:Object the value to which the specified key is mapped, or `null` if this map contains no mapping for the key

public Object get(Object name)

Implements java.util.Map.get.

Doc from java.util.Map.get.

Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

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

If this map permits null values, then 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.

Parameters

name:Object: the key whose associated value is to be returned

Returns:Object

the value to which the specified key is mapped, or null if this map contains no mapping for the key

getString	back to summary
public String getString(Object name) Get value as String. Single valued items are converted to a String with the toString() Object method. Multi valued entries are converted to a comma separated List. No quoting of commas within values is performed. Parameters name:Object The entry key. Returns:String String value.

getString

back to summary

public String getString(Object name)

Get value as String. Single valued items are converted to a String with the toString() Object method. Multi valued entries are converted to a comma separated List. No quoting of commas within values is performed.

Parameters

name:Object: The entry key.

Returns:String

String value.

getValue	back to summary
public Object getValue(Object name, int i) Get a value from a multiple value. If the value is not a multivalue, then index 0 retrieves the value or null. Parameters name:Object The entry key. i:int Index of element to get. Returns:Object Unmodifieable List of values.

getValue

back to summary

public Object getValue(Object name, int i)

Get a value from a multiple value. If the value is not a multivalue, then index 0 retrieves the value or null.

Parameters

name:Object: The entry key.
i:int: Index of element to get.

Returns:Object

Unmodifieable List of values.

getValues	back to summary
public List<E> getValues(Object name) Get multiple values. Single valued entries are converted to singleton lists. Parameters name:Object The entry key. Returns:List<E> Unmodifieable List of values.

getValues

back to summary

public List<E> getValues(Object name)

Get multiple values. Single valued entries are converted to singleton lists.

Parameters

name:Object: The entry key.

Returns:List<E>

Unmodifieable List of values.

hashCode back to summary

hashCode	back to summary
public int hashCode() Overrides java.lang.Object.hashCode. Implements java.util.Map.hashCode. Doc from java.util.Map.hashCode. Returns the hash code value for this map. The hash code of a map is defined to be the sum of the hash codes of each entry in the map's `entrySet()` view. This ensures that `m1.equals(m2)` implies that `m1.hashCode()==m2.hashCode()` for any two maps `m1` and `m2`, as required by the general contract of `Object#hashCode`. Returns:int the hash code value for this map

public int hashCode()

Overrides java.lang.Object.hashCode.

Implements java.util.Map.hashCode.

Doc from java.util.Map.hashCode.

Returns the hash code value for this map. The hash code of a map is defined to be the sum of the hash codes of each entry in the map's entrySet() view. This ensures that m1.equals(m2) implies that m1.hashCode()==m2.hashCode() for any two maps m1 and m2, as required by the general contract of Object#hashCode.

Returns:int: the hash code value for this map

isEmpty back to summary

isEmpty	back to summary
public boolean isEmpty() Implements java.util.Map.isEmpty. Doc from java.util.Map.isEmpty. Returns `true` if this map contains no key-value mappings. Returns:boolean `true` if this map contains no key-value mappings

public boolean isEmpty()

Implements java.util.Map.isEmpty.

Doc from java.util.Map.isEmpty.

Returns true if this map contains no key-value mappings.

Returns:boolean: true if this map contains no key-value mappings

keySet back to summary

keySet	back to summary
public Set<K> keySet() Implements java.util.Map.keySet. Doc from java.util.Map.keySet. Returns a `Set` view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll`, and `clear` operations. It does not support the `add` or `addAll` operations. Returns:Set<K> a set view of the keys contained in this map

public Set<K> keySet()

Implements java.util.Map.keySet.

Doc from java.util.Map.keySet.

Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

Returns:Set<K>: a set view of the keys contained in this map

put	back to summary
public Object put(K name, Object value) Implements java.util.Map.put. Put and entry into the map. Parameters name:K The entry key. value:Object The entry value. Returns:Object The previous value or null.

put

back to summary

public Object put(K name, Object value)

Implements java.util.Map.put.

Put and entry into the map.

Parameters

name:K: The entry key.
value:Object: The entry value.

Returns:Object

The previous value or null.

putAll	back to summary
public void putAll(Map<K, V> m) Implements java.util.Map.putAll. Put all contents of map. Parameters m:Map<K, V> Map

putAll

back to summary

public void putAll(Map<K, V> m)

Implements java.util.Map.putAll.

Put all contents of map.

Parameters

m:Map<K, V>: Map

putIfAbsent back to summary

putIfAbsent	back to summary
public Object putIfAbsent(K key, Object value) Implements java.util.concurrent.ConcurrentMap.putIfAbsent. Doc from java.util.concurrent.ConcurrentMap.putIfAbsent. If the specified key is not already associated with a value, associates it with the given value. This is equivalent to, for this `map`: `if (!map.containsKey(key)) return map.put(key, value); else return map.get(key);` except that the action is performed atomically. Parameters key:K key with which the specified value is to be associated value:Object value to be associated with the specified key Returns:Object the previous value associated with the specified key, or `null` if there was no mapping for the key. (A `null` return can also indicate that the map previously associated `null` with the key, if the implementation supports null values.)

public Object putIfAbsent(K key, Object value)

Implements java.util.concurrent.ConcurrentMap.putIfAbsent.

Doc from java.util.concurrent.ConcurrentMap.putIfAbsent.

If the specified key is not already associated with a value, associates it with the given value. This is equivalent to, for this map:

 if (!map.containsKey(key))
  return map.put(key, value);
else
  return map.get(key);

except that the action is performed atomically.

Parameters

key:K: key with which the specified value is to be associated
value:Object: value to be associated with the specified key

Returns:Object

the previous value associated with the specified key, or null if there was no mapping for the key. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

putValues	back to summary
public Object putValues(K name, List<E> values) Put multi valued entry. Parameters name:K The entry key. values:List<E> The List of multiple values. Returns:Object The previous value or null.

putValues

back to summary

public Object putValues(K name, List<E> values)

Put multi valued entry.

Parameters

name:K: The entry key.
values:List<E>: The List of multiple values.

Returns:Object

The previous value or null.

putValues	back to summary
public Object putValues(K name, String[] values) Put multi valued entry. Parameters name:K The entry key. values:String[] The String array of multiple values. Returns:Object The previous value or null.

putValues

back to summary

public Object putValues(K name, String[] values)

Put multi valued entry.

Parameters

name:K: The entry key.
values:String[]: The String array of multiple values.

Returns:Object

The previous value or null.

remove back to summary

remove	back to summary
public Object remove(Object key) Implements java.util.Map.remove. Doc from java.util.Map.remove. Removes the mapping for a 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 `Objects.equals(key, k)`, that mapping is removed. (The map can contain at most one such mapping.) Returns the value to which this map previously associated the key, or `null` if the map contained no mapping for the key. If this map permits null values, then a return value of `null` does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to `null`. The map will not contain a mapping for the specified key once the call returns. Parameters key:Object key whose mapping is to be removed from the map Returns:Object the previous value associated with `key`, or `null` if there was no mapping for `key`.

public Object remove(Object key)

Implements java.util.Map.remove.

Doc from java.util.Map.remove.

Removes the mapping for a 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 Objects.equals(key, k), that mapping is removed. (The map can contain at most one such mapping.)

Returns the value to which this map previously associated the key, or null if the map contained no mapping for the key.

If this map permits null values, then a return value of null does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to null.

The map will not contain a mapping for the specified key once the call returns.

Parameters

key:Object: key whose mapping is to be removed from the map

Returns:Object

the previous value associated with key, or null if there was no mapping for key.

remove back to summary

remove	back to summary
public boolean remove(Object key, Object value) Implements java.util.concurrent.ConcurrentMap.remove. Doc from java.util.concurrent.ConcurrentMap.remove. Removes the entry for a key only if currently mapped to a given value. This is equivalent to, for this `map`: `if (map.containsKey(key) && Objects.equals(map.get(key), value)) { map.remove(key); return true; } else { return false; }` except that the action is performed atomically. Parameters key:Object key with which the specified value is associated value:Object value expected to be associated with the specified key Returns:boolean `true` if the value was removed

public boolean remove(Object key, Object value)

Implements java.util.concurrent.ConcurrentMap.remove.

Doc from java.util.concurrent.ConcurrentMap.remove.

Removes the entry for a key only if currently mapped to a given value. This is equivalent to, for this map:

 if (map.containsKey(key)
    && Objects.equals(map.get(key), value)) {
  map.remove(key);
  return true;
} else {
  return false;
}

except that the action is performed atomically.

Parameters

key:Object: key with which the specified value is associated
value:Object: value expected to be associated with the specified key

Returns:boolean

true if the value was removed

removeValue	back to summary
public boolean removeValue(K name, Object value) Remove value. Parameters name:K The entry key. value:Object The entry value. Returns:boolean true if it was removed.

removeValue

back to summary

public boolean removeValue(K name, Object value)

Remove value.

Parameters

name:K: The entry key.
value:Object: The entry value.

Returns:boolean

true if it was removed.

replace back to summary

replace	back to summary
public boolean replace(K key, Object oldValue, Object newValue) Implements java.util.concurrent.ConcurrentMap.replace. Doc from java.util.concurrent.ConcurrentMap.replace. Replaces the entry for a key only if currently mapped to a given value. This is equivalent to, for this `map`: `if (map.containsKey(key) && Objects.equals(map.get(key), oldValue)) { map.put(key, newValue); return true; } else { return false; }` except that the action is performed atomically. Parameters key:K key with which the specified value is associated oldValue:Object value expected to be associated with the specified key newValue:Object value to be associated with the specified key Returns:boolean `true` if the value was replaced

public boolean replace(K key, Object oldValue, Object newValue)

Implements java.util.concurrent.ConcurrentMap.replace.

Doc from java.util.concurrent.ConcurrentMap.replace.

Replaces the entry for a key only if currently mapped to a given value. This is equivalent to, for this map:

 if (map.containsKey(key)
    && Objects.equals(map.get(key), oldValue)) {
  map.put(key, newValue);
  return true;
} else {
  return false;
}

except that the action is performed atomically.

Parameters

key:K: key with which the specified value is associated
oldValue:Object: value expected to be associated with the specified key
newValue:Object: value to be associated with the specified key

Returns:boolean

true if the value was replaced

replace back to summary

replace	back to summary
public Object replace(K key, Object value) Implements java.util.concurrent.ConcurrentMap.replace. Doc from java.util.concurrent.ConcurrentMap.replace. Replaces the entry for a key only if currently mapped to some value. This is equivalent to, for this `map`: `if (map.containsKey(key)) return map.put(key, value); else return null;` except that the action is performed atomically. Parameters key:K key with which the specified value is associated value:Object value to be associated with the specified key Returns:Object the previous value associated with the specified key, or `null` if there was no mapping for the key. (A `null` return can also indicate that the map previously associated `null` with the key, if the implementation supports null values.)

public Object replace(K key, Object value)

Implements java.util.concurrent.ConcurrentMap.replace.

Doc from java.util.concurrent.ConcurrentMap.replace.

Replaces the entry for a key only if currently mapped to some value. This is equivalent to, for this map:

 if (map.containsKey(key))
  return map.put(key, value);
else
  return null;

except that the action is performed atomically.

Parameters

key:K: key with which the specified value is associated
value:Object: value to be associated with the specified key

Returns:Object

size back to summary

size	back to summary
public int size() Implements java.util.Map.size. Doc from java.util.Map.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`. Returns:int the number of key-value mappings in this map

public int size()

Implements java.util.Map.size.

Doc from java.util.Map.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.

Returns:int: the number of key-value mappings in this map

toStringArrayMap	back to summary
public Map<K, V> toStringArrayMap() Returns:Map<K, V> Map of String arrays

values back to summary

values	back to summary
public Collection<Object> values() Implements java.util.Map.values. Doc from java.util.Map.values. Returns a `Collection` view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Collection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations. Returns:Collection<Object> a collection view of the values contained in this map

public Collection<Object> values()

Implements java.util.Map.values.

Doc from java.util.Map.values.

Returns a Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Collection.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.

Returns:Collection<Object>: a collection view of the values contained in this map

public Class MultiMap<K>

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail