K - the type of keys maintained by this map.V - the type of mapped values.public class MultivaluedHashMap<K,V> extends AbstractMultivaluedMap<K,V> implements Serializable
MultivaluedMap interface.
This implementation provides all of the optional map operations. This class
makes no guarantees as to the order of the map; in particular, it does not
guarantee that the order will remain constant over time. The implementation
permits null key. By default the implementation does also permit
null values, but ignores them. This behavior can be customized
by overriding the protected addNull(...) and
addFirstNull(...) methods.
This implementation provides constant-time performance for the basic
operations (get and put), assuming the hash function
disperses the elements properly among the buckets. Iteration over
collection views requires time proportional to the "capacity" of the
map instance (the number of buckets) plus its size (the number
of key-value mappings). Thus, it's very important not to set the initial
capacity too high (or the load factor too low) if iteration performance is
important.
An instance of MultivaluedHashMap has two parameters that affect its
performance: initial capacity and load factor. The capacity
is the number of buckets in the hash table, and the initial capacity is simply
the capacity at the time the hash table is created. The load factor is
a measure of how full the hash table is allowed to get before its capacity is
automatically increased. When the number of entries in the hash table exceeds
the product of the load factor and the current capacity, the hash table is
rehashed (that is, internal data structures are rebuilt) so that the
hash table has approximately twice the number of buckets.
As a general rule, the default load factor (.75) offers a good tradeoff
between time and space costs. Higher values decrease the space overhead
but increase the lookup cost (reflected in most of the operations of the
HashMap class, including get and put). The
expected number of entries in the map and its load factor should be taken
into account when setting its initial capacity, so as to minimize the
number of rehash operations. If the initial capacity is greater
than the maximum number of entries divided by the load factor, no
rehash operations will ever occur.
If many mappings are to be stored in a MultivaluedHashMap instance,
creating it with a sufficiently large capacity will allow the mappings to
be stored more efficiently than letting it perform automatic rehashing as
needed to grow the table.
Note that this implementation is not guaranteed to be synchronized.
If multiple threads access a hash map concurrently, and at least one of
the threads modifies the map structurally, it must be
synchronized externally. (A structural modification is any operation
that adds or deletes one or more mappings; merely changing the value
associated with a key that an instance already contains is not a
structural modification.) This is typically accomplished by
synchronizing on some object that naturally encapsulates the map.
The iterators returned by all of this class's "collection view methods"
are fail-fast: if the map is structurally modified at any time after
the iterator is created, in any way except through the iterator's own
remove method, the iterator will throw a ConcurrentModificationException.
Thus, in the face of concurrent modification, the iterator fails quickly and
cleanly, rather than risking arbitrary, non-deterministic behavior at an
undetermined time in the future.
Note that the fail-fast behavior of an iterator cannot be guaranteed
as it is, generally speaking, impossible to make any hard guarantees in the
presence of unsynchronized concurrent modification. Fail-fast iterators
throw ConcurrentModificationException on a best-effort basis.
Therefore, it would be wrong to write a program that depended on this
exception for its correctness: the fail-fast behavior of iterators
should be used only to detect bugs.store| Constructor and Description |
|---|
MultivaluedHashMap()
Constructs an empty multivalued hash map with the default initial capacity
(
16) and the default load factor (0.75). |
MultivaluedHashMap(int initialCapacity)
Constructs an empty multivalued hash map with the specified initial
capacity and the default load factor (
0.75). |
MultivaluedHashMap(int initialCapacity,
float loadFactor)
Constructs an empty multivalued hash map with the specified initial
capacity and load factor.
|
MultivaluedHashMap(Map<? extends K,? extends V> map)
Constructs a new multivalued hash map with the same mappings as the
specified single-valued
Map. |
MultivaluedHashMap(MultivaluedMap<? extends K,? extends V> map)
Constructs a new multivalued hash map with the same mappings as the
specified
MultivaluedMap. |
add, addAll, addAll, addFirst, addFirstNull, addNull, clear, containsKey, containsValue, entrySet, equals, equalsIgnoreValueOrder, get, getFirst, getValues, hashCode, isEmpty, keySet, put, putAll, putSingle, remove, size, toString, valuespublic MultivaluedHashMap()
16) and the default load factor (0.75).public MultivaluedHashMap(int initialCapacity)
0.75).initialCapacity - the initial capacity.IllegalArgumentException - if the initial capacity is negative.public MultivaluedHashMap(int initialCapacity,
float loadFactor)
initialCapacity - the initial capacityloadFactor - the load factorIllegalArgumentException - if the initial capacity is negative
or the load factor is nonpositivepublic MultivaluedHashMap(MultivaluedMap<? extends K,? extends V> map)
MultivaluedMap. The List instances holding
the values of each key are created anew instead of being reused.map - the multivalued map whose mappings are to be placed in this
multivalued map.NullPointerException - if the specified map is nullpublic MultivaluedHashMap(Map<? extends K,? extends V> map)
Map.map - the single-valued map whose mappings are to be placed in this
multivalued map.NullPointerException - if the specified map is nullCopyright © 2014. All Rights Reserved.