public abstract class AbstractInt2ObjectFunction<V> extends Object implements Int2ObjectFunction<V>, Serializable
Optional operations just throw an UnsupportedOperationException
. Generic versions of accessors delegate to the corresponding type-specific counterparts following the interface rules
(they take care of returning null
on a missing key).
This class handles directly a default return value (including methods to access it). Instances of classes inheriting from this class have just to return
defRetValue
to denote lack of a key in type-specific methods. The value is serialized.
Implementing subclasses have just to provide type-specific get()
, type-specific containsKey()
, and size()
methods.
Modifier and Type | Method and Description |
---|---|
void |
clear()
Removes all associations from this function (optional operation).
|
boolean |
containsKey(Object ok)
Returns true if this function contains a mapping for the specified key.
|
V |
defaultReturnValue()
Gets the default return value.
|
void |
defaultReturnValue(V rv)
Sets the default return value.
|
V |
get(Object ok)
Delegates to the corresponding type-specific method, taking care of returning
null on a missing key. |
V |
put(Integer ok,
V ov)
Delegates to the corresponding type-specific method, taking care of returning
null on a missing key. |
V |
put(int key,
V value)
Adds a pair to the map.
|
V |
remove(int key)
Removes the mapping with the given key.
|
V |
remove(Object ok)
Delegates to the corresponding type-specific method, taking care of returning
null on a missing key. |
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
containsKey, get
public void defaultReturnValue(V rv)
Int2ObjectFunction
get()
, put()
and remove()
to denote that the map does not contain the specified key. It must be
0/false
/null
by default.defaultReturnValue
in interface Int2ObjectFunction<V>
rv
- the new default return value.Int2ObjectFunction.defaultReturnValue()
public V defaultReturnValue()
Int2ObjectFunction
defaultReturnValue
in interface Int2ObjectFunction<V>
public V put(int key, V value)
Int2ObjectFunction
put
in interface Int2ObjectFunction<V>
key
- the key.value
- the value.Function.put(Object,Object)
public V remove(int key)
Int2ObjectFunction
remove
in interface Int2ObjectFunction<V>
key
- the key.Function.remove(Object)
public void clear()
Function
clear
in interface Function<Integer,V>
Map.clear()
public boolean containsKey(Object ok)
Function
Note that for some kind of functions (e.g., hashes) this method will always return true.
containsKey
in interface Function<Integer,V>
ok
- the key.key
.Map.containsKey(Object)
public V get(Object ok)
null
on a missing key.
This method must check whether the provided key is in the map using containsKey()
. Thus, it probes the map twice. Implementors of subclasses should override it with a
more efficient method.
get
in interface Function<Integer,V>
ok
- the key.null
if no value was present for the given key.Map.get(Object)
public V put(Integer ok, V ov)
null
on a missing key.
This method must check whether the provided key is in the map using containsKey()
. Thus, it probes the map twice. Implementors of subclasses should override it with a
more efficient method.
put
in interface Function<Integer,V>
ok
- the key.ov
- the value.null
if no value was present for the given key.Map.put(Object,Object)
public V remove(Object ok)
null
on a missing key.
This method must check whether the provided key is in the map using containsKey()
. Thus, it probes the map twice. Implementors of subclasses should override it with a
more efficient method.
remove
in interface Function<Integer,V>
ok
- the key.null
if no value was present for the given key.Map.remove(Object)