|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectfabric.common.util.AbstractLongKeyMap<V>
fabric.common.util.LongKeyHashMap<V>
public class LongKeyHashMap<V>
This class provides a hashtable-backed implementation of the Map interface.
It uses a hash-bucket approach; that is, hash collisions are handled by linking the new node off of the pre-existing node (or list of nodes). In this manner, techniques such as linear probing (which can cause primary clustering) and rehashing (which does not fit very well with Java's method of precomputing hash codes) are avoided.
Under ideal circumstances (no collisions), HashMap offers O(1)
performance on most operations (containsValue()
is,
of course, O(n)). In the worst case (all keys map to the same
hash code -- very unlikely), most operations are O(n).
HashMap is part of the JDK1.2 Collections API. It differs from
Hashtable in that it accepts the null key and null values, and it
does not support "Enumeration views." Also, it is not synchronized;
if you plan to use it in multiple threads, consider using:
Map m = Collections.synchronizedMap(new HashMap(...));
The iterators are fail-fast, meaning that any structural
modification, except for remove()
called on the iterator
itself, cause the iterator to throw a
ConcurrentModificationException
rather than exhibit
non-deterministic behavior.
LongCollection
,
LongKeyMap
,
Serialized FormNested Class Summary |
---|
Nested classes/interfaces inherited from class fabric.common.util.AbstractLongKeyMap |
---|
AbstractLongKeyMap.SimpleEntry<V>, AbstractLongKeyMap.SimpleImmutableEntry<V> |
Nested classes/interfaces inherited from interface fabric.common.util.LongKeyMap |
---|
LongKeyMap.Entry<V> |
Constructor Summary | |
---|---|
LongKeyHashMap()
Construct a new HashMap with the default capacity (11) and the default load factor (1). |
|
LongKeyHashMap(int initialCapacity)
Construct a new HashMap with a specific inital capacity and default load factor of 1. |
|
LongKeyHashMap(int initialCapacity,
float loadFactor)
Construct a new HashMap with a specific inital capacity and load factor. |
|
LongKeyHashMap(LongKeyMap<? extends V> m)
Construct a new HashMap from the given Map, with initial capacity the greater of the size of m or the default of 11. |
Method Summary | ||
---|---|---|
void |
clear()
Clears the Map so it has no keys. |
|
java.lang.Object |
clone()
Returns a shallow clone of this HashMap. |
|
boolean |
containsKey(long key)
Returns true if the supplied object equals() a key
in this HashMap. |
|
boolean |
containsValue(java.lang.Object value)
Returns true if this HashMap contains a value o , such that
o.equals(value) . |
|
java.util.Set<LongKeyMap.Entry<V>> |
entrySet()
Returns a "set view" of this HashMap's entries. |
|
V |
get(long key)
Return the value in this HashMap associated with the supplied key, or null if the key maps to nothing. |
|
boolean |
isEmpty()
Returns true if there are no key-value mappings currently in this Map. |
|
LongSet |
keySet()
Returns a "set view" of this HashMap's keys. |
|
V |
put(long key,
V value)
Puts the supplied value into the Map, mapped by the supplied key. |
|
|
putAll(LongKeyMap<T> m)
Copies all elements of the given map into this hashtable. |
|
V |
remove(long key)
Removes from the HashMap and returns the value which is mapped by the supplied key. |
|
int |
size()
Returns the number of kay-value mappings currently in this Map. |
|
java.util.Collection<V> |
values()
Returns a "collection view" (or "bag view") of this HashMap's values. |
Methods inherited from class fabric.common.util.AbstractLongKeyMap |
---|
equals, hashCode, toString |
Methods inherited from class java.lang.Object |
---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
Methods inherited from interface fabric.common.util.LongKeyMap |
---|
equals, hashCode |
Constructor Detail |
---|
public LongKeyHashMap()
public LongKeyHashMap(LongKeyMap<? extends V> m)
m
or the default of 11.
Every element in Map m will be put into this new HashMap.
m
- a Map whose key / value pairs will be put into the new HashMap.
NOTE: key / value pairs are not cloned in this constructor.
java.lang.NullPointerException
- if m is nullpublic LongKeyHashMap(int initialCapacity)
initialCapacity
- the initial capacity of this HashMap (>=0)
java.lang.IllegalArgumentException
- if (initialCapacity < 0)public LongKeyHashMap(int initialCapacity, float loadFactor)
initialCapacity
- the initial capacity (>=0)loadFactor
- the load factor (> 0, not NaN)
java.lang.IllegalArgumentException
- if (initialCapacity < 0) ||
! (loadFactor > 0.0)Method Detail |
---|
public int size()
size
in interface LongKeyMap<V>
size
in class AbstractLongKeyMap<V>
Set.size()
public boolean isEmpty()
isEmpty
in interface LongKeyMap<V>
isEmpty
in class AbstractLongKeyMap<V>
size() == 0
AbstractLongKeyMap.size()
public V get(long key)
null
if the key maps to nothing. NOTE: Since the value
could also be null, you must use containsKey to see if this key
actually maps to something.
get
in interface LongKeyMap<V>
get
in class AbstractLongKeyMap<V>
key
- the key for which to fetch an associated value
put(long, Object)
,
containsKey(long)
public boolean containsKey(long key)
equals()
a key
in this HashMap.
containsKey
in interface LongKeyMap<V>
containsKey
in class AbstractLongKeyMap<V>
key
- the key to search for in this HashMap
containsValue(Object)
public V put(long key, V value)
equals()
this key. NOTE: Since the prior value could also be null, you must
first use containsKey if you want to see if you are replacing the
key's mapping.
put
in interface LongKeyMap<V>
put
in class AbstractLongKeyMap<V>
key
- the key used to locate the valuevalue
- the value to be stored in the HashMap
get(long)
public <T extends V> void putAll(LongKeyMap<T> m)
putAll
in interface LongKeyMap<V>
putAll
in class AbstractLongKeyMap<V>
m
- the map to be hashed into thisAbstractLongKeyMap.put(long, Object)
public V remove(long key)
null
is returned. NOTE: Since the value
could also be null, you must use containsKey to see if you are
actually removing a mapping.
remove
in interface LongKeyMap<V>
remove
in class AbstractLongKeyMap<V>
key
- the key used to locate the value to remove
Iterator.remove()
public void clear()
clear
in interface LongKeyMap<V>
clear
in class AbstractLongKeyMap<V>
LongSet.clear()
public boolean containsValue(java.lang.Object value)
o
, such that
o.equals(value)
.
containsValue
in interface LongKeyMap<V>
containsValue
in class AbstractLongKeyMap<V>
value
- the value to search for in this HashMap
containsKey(long)
public java.lang.Object clone()
clone
in class AbstractLongKeyMap<V>
Cloneable
,
Object.clone()
public LongSet keySet()
keySet
in interface LongKeyMap<V>
keySet
in class AbstractLongKeyMap<V>
values()
,
entrySet()
public java.util.Collection<V> values()
values
in interface LongKeyMap<V>
values
in class AbstractLongKeyMap<V>
keySet()
,
entrySet()
public java.util.Set<LongKeyMap.Entry<V>> entrySet()
Note that the iterators for all three views, from keySet(), entrySet(), and values(), traverse the HashMap in the same sequence.
entrySet
in interface LongKeyMap<V>
entrySet
in class AbstractLongKeyMap<V>
keySet()
,
values()
,
LongKeyMap.Entry
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |