|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.google.common.collect.ImmutableMap<K,V> com.google.common.collect.ImmutableBiMap<K,V>
@GwtCompatible(serializable=true, emulated=true) public abstract class ImmutableBiMap<K,V>
An immutable BiMap
with reliable user-specified iteration order. Does
not permit null keys or values. An ImmutableBiMap
and its inverse
have the same iteration ordering.
An instance of ImmutableBiMap
contains its own data and will
never change. ImmutableBiMap
is convenient for
public static final
maps ("constant maps") and also lets you easily
make a "defensive copy" of a bimap provided to your class by a caller.
Note: Although this class is not final, it cannot be subclassed as it has no public or protected constructors. Thus, instances of this class are guaranteed to be immutable.
Nested Class Summary | |
---|---|
static class |
ImmutableBiMap.Builder<K,V>
A builder for creating immutable bimap instances, especially public
static final bimaps ("constant bimaps"). |
Nested classes/interfaces inherited from interface java.util.Map |
---|
Map.Entry<K,V> |
Method Summary | ||
---|---|---|
static
|
builder()
Returns a new builder. |
|
boolean |
containsKey(Object key)
Returns true if this map contains a mapping for the specified key. |
|
boolean |
containsValue(Object value)
Returns true if this map maps one or more keys to the specified value. |
|
static
|
copyOf(Map<? extends K,? extends V> map)
Returns an immutable bimap containing the same entries as map . |
|
ImmutableSet<Map.Entry<K,V>> |
entrySet()
Returns an immutable set of the mappings in this map. |
|
boolean |
equals(Object object)
Indicates whether some other object is "equal to" this one. |
|
V |
forcePut(K key,
V value)
Guaranteed to throw an exception and leave the bimap unmodified. |
|
V |
get(Object key)
Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key. |
|
int |
hashCode()
Returns a hash code value for the object. |
|
abstract ImmutableBiMap<V,K> |
inverse()
Returns the inverse view of this bimap, which maps each of this bimap's values to its associated key. |
|
boolean |
isEmpty()
Returns true if this map contains no key-value mappings. |
|
ImmutableSet<K> |
keySet()
Returns an immutable set of the keys in this map. |
|
static
|
of()
Returns the empty bimap. |
|
static
|
of(K k1,
V v1)
Returns an immutable bimap containing a single entry. |
|
static
|
of(K k1,
V v1,
K k2,
V v2)
Returns an immutable map containing the given entries, in order. |
|
static
|
of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3)
Returns an immutable map containing the given entries, in order. |
|
static
|
of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4)
Returns an immutable map containing the given entries, in order. |
|
static
|
of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4,
K k5,
V v5)
Returns an immutable map containing the given entries, in order. |
|
int |
size()
Returns the number of key-value mappings in this map. |
|
String |
toString()
Returns a string representation of the object. |
|
ImmutableSet<V> |
values()
Returns an immutable set of the values in this map. |
Methods inherited from class com.google.common.collect.ImmutableMap |
---|
clear, put, putAll, remove |
Methods inherited from class java.lang.Object |
---|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait |
Methods inherited from interface com.google.common.collect.BiMap |
---|
put, putAll |
Methods inherited from interface java.util.Map |
---|
clear, remove |
Method Detail |
---|
public static <K,V> ImmutableBiMap<K,V> of()
public static <K,V> ImmutableBiMap<K,V> of(K k1, V v1)
public static <K,V> ImmutableBiMap<K,V> of(K k1, V v1, K k2, V v2)
IllegalArgumentException
- if duplicate keys or values are addedpublic static <K,V> ImmutableBiMap<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3)
IllegalArgumentException
- if duplicate keys or values are addedpublic static <K,V> ImmutableBiMap<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)
IllegalArgumentException
- if duplicate keys or values are addedpublic static <K,V> ImmutableBiMap<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)
IllegalArgumentException
- if duplicate keys or values are addedpublic static <K,V> ImmutableBiMap.Builder<K,V> builder()
ImmutableBiMap.Builder
constructor.
public static <K,V> ImmutableBiMap<K,V> copyOf(Map<? extends K,? extends V> map)
map
. If
map
somehow contains entries with duplicate keys (for example, if
it is a SortedMap
whose comparator is not consistent with
equals), the results of this method are undefined.
Despite the method name, this method attempts to avoid actually copying the data when it is safe to do so. The exact circumstances under which a copy will or will not be performed are undocumented and subject to change.
IllegalArgumentException
- if two keys have the same value
NullPointerException
- if any key or value in map
is nullpublic abstract ImmutableBiMap<V,K> inverse()
Note:There is no guaranteed correspondence between the iteration order of a bimap and that of its inverse.
The inverse of an ImmutableBiMap
is another
ImmutableBiMap
.
inverse
in interface BiMap<K,V>
public boolean containsKey(@Nullable Object key)
java.util.Map
containsKey
in interface Map<K,V>
containsKey
in class ImmutableMap<K,V>
key
- key whose presence in this map is to be tested
public boolean containsValue(@Nullable Object value)
java.util.Map
containsValue
in interface Map<K,V>
containsValue
in class ImmutableMap<K,V>
value
- value whose presence in this map is to be tested
public ImmutableSet<Map.Entry<K,V>> entrySet()
ImmutableMap
entrySet
in interface Map<K,V>
entrySet
in class ImmutableMap<K,V>
public V get(@Nullable Object key)
java.util.Map
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 (key==null ? k==null :
key.equals(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.
get
in interface Map<K,V>
get
in class ImmutableMap<K,V>
key
- the key whose associated value is to be returned
null
if this map contains no mapping for the keypublic ImmutableSet<K> keySet()
ImmutableMap
keySet
in interface Map<K,V>
keySet
in class ImmutableMap<K,V>
public ImmutableSet<V> values()
values
in interface BiMap<K,V>
values
in interface Map<K,V>
values
in class ImmutableMap<K,V>
public V forcePut(K key, V value)
forcePut
in interface BiMap<K,V>
key
- the key with which the specified value is to be associatedvalue
- the value to be associated with the specified key
null
, or null
if there was no previous entry
UnsupportedOperationException
- alwayspublic boolean isEmpty()
java.util.Map
isEmpty
in interface Map<K,V>
isEmpty
in class ImmutableMap<K,V>
public int size()
java.util.Map
size
in interface Map<K,V>
public boolean equals(@Nullable Object object)
java.lang.Object
The equals
method implements an equivalence relation
on non-null object references:
x
, x.equals(x)
should return
true
.
x
and y
, x.equals(y)
should return true
if and only if
y.equals(x)
returns true
.
x
, y
, and z
, if
x.equals(y)
returns true
and
y.equals(z)
returns true
, then
x.equals(z)
should return true
.
x
and y
, multiple invocations of
x.equals(y) consistently return true
or consistently return false
, provided no
information used in equals
comparisons on the
objects is modified.
x
,
x.equals(null)
should return false
.
The equals method for class Object
implements
the most discriminating possible equivalence relation on objects;
that is, for any non-null reference values x
and
y
, this method returns true
if and only
if x
and y
refer to the same object
(x == y
has the value true
).
Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
equals
in interface Map<K,V>
equals
in class ImmutableMap<K,V>
object
- the reference object with which to compare.
true
if this object is the same as the obj
argument; false
otherwise.Object.hashCode()
,
Hashtable
public int hashCode()
java.lang.Object
java.util.Hashtable
.
The general contract of hashCode
is:
hashCode
method on each of
the two objects must produce the same integer result.
Object.equals(java.lang.Object)
method, then calling the hashCode method on each of the
two objects must produce distinct integer results. However, the
programmer should be aware that producing distinct integer results
for unequal objects may improve the performance of hashtables.
As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the JavaTM programming language.)
hashCode
in interface Map<K,V>
hashCode
in class ImmutableMap<K,V>
Object.equals(java.lang.Object)
,
Hashtable
public String toString()
java.lang.Object
toString
method returns a string that
"textually represents" this object. The result should
be a concise but informative representation that is easy for a
person to read.
It is recommended that all subclasses override this method.
The toString
method for class Object
returns a string consisting of the name of the class of which the
object is an instance, the at-sign character `@
', and
the unsigned hexadecimal representation of the hash code of the
object. In other words, this method returns a string equal to the
value of:
getClass().getName() + '@' + Integer.toHexString(hashCode())
toString
in class ImmutableMap<K,V>
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |