|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectcom.google.common.collect.Maps
public final class Maps
Static utility methods pertaining to Map
instances. Also see this
class's counterparts Lists
and Sets
.
Method Summary | ||
---|---|---|
static boolean |
containsEntry(Map<?,?> map,
Object key,
Object value)
Returns true if map contains an entry mapping key
to value . |
|
static Map<String,String> |
fromProperties(Properties properties)
Creates a Map<String, String> from a Properties instance. |
|
static
|
immutableEntry(K key,
V value)
Returns an immutable map entry with the specified key and value. |
|
static
|
newClassToInstanceMap()
Returns a new ClassToInstanceMap instance backed by a HashMap using the default initial capacity and load factor. |
|
static
|
newClassToInstanceMap(Map<Class<? extends B>,B> backingMap)
Returns a new ClassToInstanceMap instance backed by a given empty
backingMap . |
|
static
|
newConcurrentHashMap()
Creates a ConcurrentHashMap instance. |
|
static
|
newEnumBiMap(Class<K> keyType,
Class<V> valueType)
Returns a new empty EnumBiMap using the specified key and value
types. |
|
static
|
newEnumHashBiMap(Class<K> keyType)
Returns a new empty EnumHashBiMap using the specified key type. |
|
static
|
newEnumMap(Class<K> type)
Creates an EnumMap instance. |
|
static
|
newHashBiMap()
Returns a new empty HashBiMap with the default initial capacity
(16). |
|
static
|
newHashMap()
Creates a HashMap instance. |
|
static
|
newHashMap(Map<? extends K,? extends V> map)
Creates a HashMap instance with the same mappings as the specified
map. |
|
static
|
newHashMapWithExpectedSize(int expectedSize)
Creates a HashMap instance with enough capacity to hold the
specified number of elements without rehashing. |
|
static
|
newIdentityHashMap()
Creates an IdentityHashMap instance. |
|
static
|
newLinkedHashMap()
Creates an insertion-ordered LinkedHashMap instance. |
|
static
|
newLinkedHashMap(Map<? extends K,? extends V> map)
Creates an insertion-ordered LinkedHashMap instance with the same
mappings as the specified map. |
|
static
|
newTreeMap()
Creates a TreeMap instance using the natural ordering of its
elements. |
|
static
|
newTreeMap(Comparator<C> comparator)
Creates a TreeMap instance using the given comparator. |
|
static
|
synchronizedBiMap(BiMap<K,V> bimap)
Returns a synchronized (thread-safe) bimap backed by the specified bimap. |
|
static
|
uniqueIndex(Iterable<V> values,
Function<? super V,K> keyFunction)
Returns an immutable map for which the Map.values() are the given
elements in the given order, and each key is the product of invoking a
supplied function on its corresponding value. |
|
static
|
unmodifiableBiMap(BiMap<K,V> bimap)
Returns an unmodifiable view of the specified bimap. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Method Detail |
---|
public static <K,V> HashMap<K,V> newHashMap()
HashMap
instance.
Note: if K
is an enum
type, use newEnumMap(java.lang.Class
instead.
Note: if you don't actually need the resulting map to be mutable,
use Collections.emptyMap()
instead.
HashMap
public static <K,V> HashMap<K,V> newHashMapWithExpectedSize(int expectedSize)
HashMap
instance with enough capacity to hold the
specified number of elements without rehashing.
expectedSize
- the expected size
HashMap
, initially empty, with enough
capacity to hold expectedSize
elements without rehashing
IllegalArgumentException
- if expectedSize
is negativepublic static <K,V> HashMap<K,V> newHashMap(Map<? extends K,? extends V> map)
HashMap
instance with the same mappings as the specified
map.
Note: if K
is an Enum
type, use newEnumMap(java.lang.Class
instead.
map
- the mappings to be placed in the new map
HashMap
initialized with the mappings from
map
public static <K,V> LinkedHashMap<K,V> newLinkedHashMap()
LinkedHashMap
instance.
LinkedHashMap
public static <K,V> LinkedHashMap<K,V> newLinkedHashMap(Map<? extends K,? extends V> map)
LinkedHashMap
instance with the same
mappings as the specified map.
map
- the mappings to be placed in the new map
LinkedHashMap
initialized with the
mappings from map
public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap()
ConcurrentHashMap
instance.
ConcurrentHashMap
public static <K extends Comparable,V> TreeMap<K,V> newTreeMap()
TreeMap
instance using the natural ordering of its
elements.
TreeMap
public static <C,K extends C,V> TreeMap<K,V> newTreeMap(@Nullable Comparator<C> comparator)
TreeMap
instance using the given comparator.
comparator
- the comparator to sort the keys with
TreeMap
public static <K extends Enum<K>,V> EnumMap<K,V> newEnumMap(Class<K> type)
EnumMap
instance.
type
- the key type for this map
EnumMap
public static <K,V> IdentityHashMap<K,V> newIdentityHashMap()
IdentityHashMap
instance.
IdentityHashMap
public static boolean containsEntry(Map<?,?> map, @Nullable Object key, @Nullable Object value)
true
if map
contains an entry mapping key
to value
. If you are not concerned with null-safety you can simply
use map.get(key).equals(value)
.
public static <K,V> BiMap<K,V> synchronizedBiMap(BiMap<K,V> bimap)
It is imperative that the user manually synchronize on the returned map when accessing any of its collection views:
Bimap<K,V> m = Maps.synchronizedBiMap( new HashBiMap<K,V>()); ... Set<K> s = m.keySet(); // Needn't be in synchronized block ... synchronized (m) { // Synchronizing on m, not s! Iterator<K> i = s.iterator(); // Must be in synchronized block while (i.hasNext()) { foo(i.next()); } }Failure to follow this advice may result in non-deterministic behavior.
bimap
- the bimap to be wrapped in a synchronized view
public static <K,V> ImmutableMap<K,V> uniqueIndex(Iterable<V> values, Function<? super V,K> keyFunction)
Map.values()
are the given
elements in the given order, and each key is the product of invoking a
supplied function on its corresponding value.
values
- the values to use when constructing the Map
keyFunction
- the function used to produce the key for each value
keyFunction
on each value in the input collection to that value
IllegalArgumentException
- if keyFunction
produces the same
key for more than one value in the input collection
NullPointerException
- if any elements of values
is null, or
if keyFunction
produces null
for any valuepublic static Map<String,String> fromProperties(Properties properties)
Map<String, String>
from a Properties
instance.
Properties normally derive from Map<Object, Object>
, but they
typically contain strings, which is awkward. This method lets you get a
plain-old-Map
out of a Properties
. The returned map won't
include any null keys or values. The returned map is modifiable and
serializable.
properties
- a Properties
object to be converted
properties
public static <K,V> Map.Entry<K,V> immutableEntry(@Nullable K key, @Nullable V value)
Map.Entry.setValue(V)
operation throws an UnsupportedOperationException
.
The returned entry is serializable.
key
- the key to be associated with the returned entryvalue
- the value to be associated with the returned entrypublic static <K,V> HashBiMap<K,V> newHashBiMap()
HashBiMap
with the default initial capacity
(16).
public static <K extends Enum<K>,V> EnumHashBiMap<K,V> newEnumHashBiMap(Class<K> keyType)
EnumHashBiMap
using the specified key type.
keyType
- the key typepublic static <K extends Enum<K>,V extends Enum<V>> EnumBiMap<K,V> newEnumBiMap(Class<K> keyType, Class<V> valueType)
EnumBiMap
using the specified key and value
types.
keyType
- the key typevalueType
- the value typepublic static <K,V> BiMap<K,V> unmodifiableBiMap(BiMap<K,V> bimap)
UnsupportedOperationException
.
The returned bimap will be serializable if the specified bimap is serializable.
bimap
- the bimap for which an unmodifiable view is to be returned
public static <B> ClassToInstanceMap<B> newClassToInstanceMap()
ClassToInstanceMap
instance backed by a HashMap
using the default initial capacity and load factor.
public static <B> ClassToInstanceMap<B> newClassToInstanceMap(Map<Class<? extends B>,B> backingMap)
ClassToInstanceMap
instance backed by a given empty
backingMap
. The caller surrenders control of the backing map, and
thus should not allow any direct references to it to remain accessible.
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |