|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectfabric.common.util.AbstractLongKeyMap<V>
public abstract class AbstractLongKeyMap<V>
An abstract implementation of Map to make it easier to create your own
implementations. In order to create an unmodifiable Map, subclass
AbstractMap and implement the entrySet
(usually via an
AbstractSet). To make it modifiable, also implement put
,
and have entrySet().iterator()
support remove
.
It is recommended that classes which extend this support at least the no-argument constructor, and a constructor which accepts another Map. Further methods in this class may be overridden if you have a more efficient implementation.
LongKeyMap
,
LongCollection
,
LongKeyHashMap
,
LongKeyCache
,
TwoKeyHashMap
Nested Class Summary | |
---|---|
static class |
AbstractLongKeyMap.SimpleEntry<V>
A class which implements Map.Entry. |
static class |
AbstractLongKeyMap.SimpleImmutableEntry<V>
A class containing an immutable key and value. |
Nested classes/interfaces inherited from interface fabric.common.util.LongKeyMap |
---|
LongKeyMap.Entry<V> |
Constructor Summary | |
---|---|
protected |
AbstractLongKeyMap()
The main constructor, for use by subclasses. |
Method Summary | ||
---|---|---|
void |
clear()
Remove all entries from this Map (optional operation). |
|
protected java.lang.Object |
clone()
Create a shallow copy of this Map, no keys or values are copied. |
|
boolean |
containsKey(long key)
Returns true if this contains a mapping for the given key. |
|
boolean |
containsValue(java.lang.Object value)
Returns true if this contains at least one mapping with the given value. |
|
abstract java.util.Set<LongKeyMap.Entry<V>> |
entrySet()
Returns a set view of the mappings in this Map. |
|
boolean |
equals(java.lang.Object o)
Compares the specified object with this map for equality. |
|
V |
get(long key)
Returns the value mapped by the given key. |
|
int |
hashCode()
Returns the hash code for this map. |
|
boolean |
isEmpty()
Returns true if the map contains no mappings. |
|
LongSet |
keySet()
Returns a set view of this map's keys. |
|
V |
put(long key,
V value)
Associates the given key to the given value (optional operation). |
|
|
putAll(LongKeyMap<T> m)
Copies all entries of the given map to this one (optional operation). |
|
V |
remove(long key)
Removes the mapping for this key if present (optional operation). |
|
int |
size()
Returns the number of key-value mappings in the map. |
|
java.lang.String |
toString()
Returns a String representation of this map. |
|
java.util.Collection<V> |
values()
Returns a collection or bag view of this map's values. |
Methods inherited from class java.lang.Object |
---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
protected AbstractLongKeyMap()
Method Detail |
---|
public abstract java.util.Set<LongKeyMap.Entry<V>> entrySet()
Iterator.remove
, Set.remove
,
removeAll
, retainAll
, and clear
.
Element addition is not supported via this set.
entrySet
in interface LongKeyMap<V>
LongKeyMap.Entry
public void clear()
AbstractMap.clear
unless you want an infinite loop.
clear
in interface LongKeyMap<V>
java.lang.UnsupportedOperationException
- if entrySet().clear()
does not support clearing.LongSet.clear()
protected java.lang.Object clone() throws java.lang.CloneNotSupportedException
super.clone()
.
clone
in class java.lang.Object
java.lang.CloneNotSupportedException
- if a subclass is not CloneableCloneable
,
Object.clone()
public boolean containsKey(long key)
entrySet()
, returning true
if a match
is found, false
if the iteration ends. Many subclasses
can implement this more efficiently.
containsKey
in interface LongKeyMap<V>
key
- the key to search for
java.lang.NullPointerException
- if key is null
but the map
does not permit null keyscontainsValue(Object)
public boolean containsValue(java.lang.Object value)
entrySet()
, returning true
if a match
is found, false
if the iteration ends. A match is
defined as a value, v, where (value == null ? v == null :
value.equals(v))
. Subclasses are unlikely to implement
this more efficiently.
containsValue
in interface LongKeyMap<V>
value
- the value to search for
containsKey(long)
public boolean equals(java.lang.Object o)
true
if the other object is a Map with the same mappings,
that is,o instanceof Map && entrySet().equals(((Map) o).entrySet();
equals
in interface LongKeyMap<V>
equals
in class java.lang.Object
o
- the object to be compared
Set.equals(Object)
public V get(long key)
null
if
there is no mapping. However, in Maps that accept null values, you
must rely on containsKey
to determine if a mapping exists.
This iteration takes linear time, searching entrySet().iterator() of
the key. Many implementations override this method.
get
in interface LongKeyMap<V>
key
- the key to look up
java.lang.NullPointerException
- if this map does not accept null keyscontainsKey(long)
public int hashCode()
hashCode
in interface LongKeyMap<V>
hashCode
in class java.lang.Object
LongKeyMap.Entry.hashCode()
,
LongSet.hashCode()
public boolean isEmpty()
size() == 0
.
isEmpty
in interface LongKeyMap<V>
size()
public LongSet keySet()
This implementation creates an AbstractSet, where the iterator wraps the entrySet iterator, size defers to the Map's size, and contains defers to the Map's containsKey. The set is created on first use, and returned on subsequent uses, although since no synchronization occurs, there is a slight possibility of creating two sets.
keySet
in interface LongKeyMap<V>
LongSet.iterator()
,
size()
,
containsKey(long)
,
values()
public V put(long key, V value)
null
values, a null return does not always
imply that the mapping was created.
put
in interface LongKeyMap<V>
key
- the key to mapvalue
- the value to be mapped
java.lang.UnsupportedOperationException
- if the operation is not supported
java.lang.ClassCastException
- if the key or value is of the wrong type
java.lang.IllegalArgumentException
- if something about this key or value
prevents it from existing in this map
java.lang.NullPointerException
- if the map forbids null keys or valuescontainsKey(long)
public <T extends V> void putAll(LongKeyMap<T> m)
put
,
so it is not supported if puts are not.
putAll
in interface LongKeyMap<V>
m
- the mapping to load into this map
java.lang.UnsupportedOperationException
- if the operation is not supported
by this map.
java.lang.ClassCastException
- if a key or value is of the wrong type for
adding to this map.
java.lang.IllegalArgumentException
- if something about a key or value
prevents it from existing in this map.
java.lang.NullPointerException
- if the map forbids null keys or values.
java.lang.NullPointerException
- if m
is null.put(long, Object)
public V remove(long key)
remove
method.
It returns the result of getValue()
on the entry, if found,
or null if no entry is found. Note that maps which permit null values
may also return null if the key was removed. If the entrySet does not
support removal, this will also fail. This is O(n), so many
implementations override it for efficiency.
remove
in interface LongKeyMap<V>
key
- the key to remove
java.lang.UnsupportedOperationException
- if deletion is unsupportedIterator.remove()
public int size()
entrySet().size()
.
size
in interface LongKeyMap<V>
Set.size()
public java.lang.String toString()
getKey() + "=" + getValue()
), separated by a comma and
space (", "), and surrounded by braces ('{' and '}'). This implementation
uses a StringBuffer and iterates over the entrySet to build the String.
Note that this can fail with an exception if underlying keys or
values complete abruptly in toString().
toString
in class java.lang.Object
AbstractLongKeyMap.SimpleEntry.toString()
,
Object.toString()
public java.util.Collection<V> values()
This implementation creates an AbstractCollection, where the iterator wraps the entrySet iterator, size defers to the Map's size, and contains defers to the Map's containsValue. The collection is created on first use, and returned on subsequent uses, although since no synchronization occurs, there is a slight possibility of creating two collections.
values
in interface LongKeyMap<V>
LongCollection.iterator()
,
size()
,
containsValue(Object)
,
keySet()
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |