|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectcom.google.common.collect.Maps
@GwtCompatible(emulated=true) public final class Maps
Static utility methods pertaining to Map instances. Also see this
class's counterparts Lists and Sets.
| Nested Class Summary | |
|---|---|
static interface |
Maps.EntryTransformer<K,V1,V2>
A transformation of the value of a key-value pair, using both key and value as inputs. |
| Method Summary | ||
|---|---|---|
static
|
difference(Map<? extends K,? extends V> left,
Map<? extends K,? extends V> right)
Computes the difference between two maps. |
|
static
|
difference(Map<? extends K,? extends V> left,
Map<? extends K,? extends V> right,
Equivalence<? super V> valueEquivalence)
Computes the difference between two maps. |
|
static
|
difference(SortedMap<K,? extends V> left,
Map<? extends K,? extends V> right)
Computes the difference between two sorted maps, using the comparator of the left map, or Ordering.natural() if the left map uses the
natural ordering of its elements. |
|
static
|
filterEntries(Map<K,V> unfiltered,
Predicate<? super Map.Entry<K,V>> entryPredicate)
Returns a map containing the mappings in unfiltered that satisfy a
predicate. |
|
static
|
filterEntries(SortedMap<K,V> unfiltered,
Predicate<? super Map.Entry<K,V>> entryPredicate)
Returns a sorted map containing the mappings in unfiltered that
satisfy a predicate. |
|
static
|
filterKeys(Map<K,V> unfiltered,
Predicate<? super K> keyPredicate)
Returns a map containing the mappings in unfiltered whose keys
satisfy a predicate. |
|
static
|
filterKeys(SortedMap<K,V> unfiltered,
Predicate<? super K> keyPredicate)
Returns a sorted map containing the mappings in unfiltered whose
keys satisfy a predicate. |
|
static
|
filterValues(Map<K,V> unfiltered,
Predicate<? super V> valuePredicate)
Returns a map containing the mappings in unfiltered whose values
satisfy a predicate. |
|
static
|
filterValues(SortedMap<K,V> unfiltered,
Predicate<? super V> valuePredicate)
Returns a sorted map containing the mappings in unfiltered whose
values satisfy a predicate. |
|
static ImmutableMap<String,String> |
fromProperties(Properties properties)
Creates an ImmutableMap<String, String> from a Properties
instance. |
|
static
|
immutableEntry(K key,
V value)
Returns an immutable map entry with the specified key and value. |
|
static
|
newConcurrentMap()
Returns a general-purpose instance of ConcurrentMap, which supports
all optional operations of the ConcurrentMap interface. |
|
static
|
newEnumMap(Class<K> type)
Creates an EnumMap instance. |
|
static
|
newEnumMap(Map<K,? extends V> map)
Creates an EnumMap with the same mappings as the specified map. |
|
static
|
newHashMap()
Creates a mutable, empty HashMap instance. |
|
static
|
newHashMap(Map<? extends K,? extends V> map)
Creates a mutable HashMap instance with the same mappings as
the specified map. |
|
static
|
newHashMapWithExpectedSize(int expectedSize)
Creates a HashMap instance, with a high enough "initial capacity"
that it should hold expectedSize elements without growth. |
|
static
|
newIdentityHashMap()
Creates an IdentityHashMap instance. |
|
static
|
newLinkedHashMap()
Creates a mutable, empty, insertion-ordered LinkedHashMap
instance. |
|
static
|
newLinkedHashMap(Map<? extends K,? extends V> map)
Creates a mutable, insertion-ordered LinkedHashMap instance
with the same mappings as the specified map. |
|
static
|
newTreeMap()
Creates a mutable, empty TreeMap instance using the natural
ordering of its elements. |
|
static
|
newTreeMap(Comparator<C> comparator)
Creates a mutable, empty TreeMap instance using the given
comparator. |
|
static
|
newTreeMap(SortedMap<K,? extends V> map)
Creates a mutable TreeMap instance with the same mappings as
the specified map and using the same ordering as the specified map. |
|
static
|
synchronizedBiMap(BiMap<K,V> bimap)
Returns a synchronized (thread-safe) bimap backed by the specified bimap. |
|
static
|
transformEntries(Map<K,V1> fromMap,
Maps.EntryTransformer<? super K,? super V1,V2> transformer)
Returns a view of a map whose values are derived from the original map's entries. |
|
static
|
transformEntries(SortedMap<K,V1> fromMap,
Maps.EntryTransformer<? super K,? super V1,V2> transformer)
Returns a view of a sorted map whose values are derived from the original sorted map's entries. |
|
static
|
transformValues(Map<K,V1> fromMap,
Function<? super V1,V2> function)
Returns a view of a map where each value is transformed by a function. |
|
static
|
transformValues(SortedMap<K,V1> fromMap,
Function<? super V1,V2> function)
Returns a view of a sorted map where each value is transformed by a function. |
|
static
|
uniqueIndex(I values,
Function<? super V,K> keyFunction)
Deprecated. use uniqueIndex(Iterator, Function) by casting values to Iterator<V>, or better yet, by implementing only
Iterator and not Iterable. This method is scheduled
for deletion in March 2012. |
|
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
|
uniqueIndex(Iterator<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<? extends K,? extends 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 mutability is not required, use ImmutableMap.of() instead.
Note: if K is an enum type, use newEnumMap(java.lang.Class instead.
HashMappublic static <K,V> HashMap<K,V> newHashMapWithExpectedSize(int expectedSize)
HashMap instance, with a high enough "initial capacity"
that it should hold expectedSize elements without growth.
This behavior cannot be broadly guaranteed, but it is observed to be true
for OpenJDK 1.6. It also can't be guaranteed that the method isn't
inadvertently oversizing the returned map.
expectedSize - the number of elements you expect to add to the
returned map
HashMap with enough capacity to hold expectedSize elements without resizing
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 mutability is not required, use ImmutableMap.copyOf(Map) instead.
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 mappublic static <K,V> LinkedHashMap<K,V> newLinkedHashMap()
LinkedHashMap
instance.
Note: if mutability is not required, use ImmutableMap.of() instead.
LinkedHashMappublic static <K,V> LinkedHashMap<K,V> newLinkedHashMap(Map<? extends K,? extends V> map)
LinkedHashMap instance
with the same mappings as the specified map.
Note: if mutability is not required, use ImmutableMap.copyOf(Map) instead.
map - the mappings to be placed in the new map
LinkedHashMap initialized with the mappings from
mappublic static <K,V> ConcurrentMap<K,V> newConcurrentMap()
ConcurrentMap, which supports
all optional operations of the ConcurrentMap interface. It does not permit
null keys or values. It is serializable.
This is currently accomplished by calling MapMaker.makeMap().
It is preferable to use MapMaker directly (rather than through
this method), as it presents numerous useful configuration options,
such as the concurrency level, load factor, key/value reference types,
and value computation.
ConcurrentMappublic static <K extends Comparable,V> TreeMap<K,V> newTreeMap()
TreeMap instance using the natural
ordering of its elements.
Note: if mutability is not required, use ImmutableSortedMap.of() instead.
TreeMappublic static <K,V> TreeMap<K,V> newTreeMap(SortedMap<K,? extends V> map)
TreeMap instance with the same mappings as
the specified map and using the same ordering as the specified map.
Note: if mutability is not required, use ImmutableSortedMap.copyOfSorted(SortedMap) instead.
map - the sorted map whose mappings are to be placed in the new map
and whose comparator is to be used to sort the new map
TreeMap initialized with the mappings from map and using the comparator of map
public static <C,K extends C,V> TreeMap<K,V> newTreeMap(@Nullable
Comparator<C> comparator)
TreeMap instance using the given
comparator.
Note: if mutability is not required, use ImmutableSortedMap.orderedBy(comparator).build() instead.
comparator - the comparator to sort the keys with
TreeMappublic static <K extends Enum<K>,V> EnumMap<K,V> newEnumMap(Class<K> type)
EnumMap instance.
type - the key type for this map
EnumMappublic static <K extends Enum<K>,V> EnumMap<K,V> newEnumMap(Map<K,? extends V> map)
EnumMap with the same mappings as the specified map.
map - the map from which to initialize this EnumMap
EnumMap initialized with the mappings from map
IllegalArgumentException - if m is not an EnumMap
instance and contains no mappingspublic static <K,V> IdentityHashMap<K,V> newIdentityHashMap()
IdentityHashMap instance.
IdentityHashMappublic 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<Long, String> map = Maps.synchronizedBiMap(
HashBiMap.<Long, String>create());
...
Set<Long> set = map.keySet(); // Needn't be in synchronized block
...
synchronized (map) { // Synchronizing on map, not set!
Iterator<Long> it = set.iterator(); // Must be in synchronized block
while (it.hasNext()) {
foo(it.next());
}
}
Failure to follow this advice may result in non-deterministic behavior.
The returned bimap will be serializable if the specified bimap is serializable.
bimap - the bimap to be wrapped in a synchronized view
public static <K,V> MapDifference<K,V> difference(Map<? extends K,? extends V> left,
Map<? extends K,? extends V> right)
Since this method uses HashMap instances internally, the keys of
the supplied maps must be well-behaved with respect to
Object.equals(java.lang.Object) and Object.hashCode().
Note:If you only need to know whether two maps have the same
mappings, call left.equals(right) instead of this method.
left - the map to treat as the "left" map for purposes of comparisonright - the map to treat as the "right" map for purposes of comparison
@Beta
public static <K,V> MapDifference<K,V> difference(Map<? extends K,? extends V> left,
Map<? extends K,? extends V> right,
Equivalence<? super V> valueEquivalence)
Values are compared using a provided equivalence, in the case of equality, the value on the 'left' is returned in the difference.
Since this method uses HashMap instances internally, the keys of
the supplied maps must be well-behaved with respect to
Object.equals(java.lang.Object) and Object.hashCode().
left - the map to treat as the "left" map for purposes of comparisonright - the map to treat as the "right" map for purposes of comparisonvalueEquivalence - the equivalence relationship to use to compare
values
@Beta
public static <K,V> SortedMapDifference<K,V> difference(SortedMap<K,? extends V> left,
Map<? extends K,? extends V> right)
Ordering.natural() if the left map uses the
natural ordering of its elements. This difference is an immutable snapshot
of the state of the maps at the time this method is called. It will never
change, even if the maps change at a later time.
Since this method uses TreeMap instances internally, the keys of
the right map must all compare as distinct according to the comparator
of the left map.
Note:If you only need to know whether two sorted maps have the
same mappings, call left.equals(right) instead of this method.
left - the map to treat as the "left" map for purposes of comparisonright - the map to treat as the "right" map for purposes of comparison
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 MapkeyFunction - 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 value
@Beta
@Deprecated
public static <K,V,I extends Object & Iterable<V> & Iterator<V>> ImmutableMap<K,V> uniqueIndex(I values,
Function<? super V,K> keyFunction)
uniqueIndex(Iterator, Function) by casting values to Iterator<V>, or better yet, by implementing only
Iterator and not Iterable. This method is scheduled
for deletion in March 2012.
public static <K,V> ImmutableMap<K,V> uniqueIndex(Iterator<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 MapkeyFunction - 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 value@GwtIncompatible(value="java.util.Properties") public static ImmutableMap<String,String> fromProperties(Properties properties)
ImmutableMap<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.
properties - a Properties object to be converted
properties
ClassCastException - if any key in Properties is not a String
NullPointerException - if any key or value in Properties is
null
@GwtCompatible(serializable=true)
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> BiMap<K,V> unmodifiableBiMap(BiMap<? extends K,? extends 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 <K,V1,V2> Map<K,V2> transformValues(Map<K,V1> fromMap,
Function<? super V1,V2> function)
Map<String, Integer> map = ImmutableMap.of("a", 4, "b", 9);
Function<Integer, Double> sqrt =
new Function<Integer, Double>() {
public Double apply(Integer in) {
return Math.sqrt((int) in);
}
};
Map<String, Double> transformed = Maps.transformValues(map, sqrt);
System.out.println(transformed);
... prints {a=2.0, b=3.0}.
Changes in the underlying map are reflected in this view. Conversely, this view supports removal operations, and these are reflected in the underlying map.
It's acceptable for the underlying map to contain null keys, and even null values provided that the function is capable of accepting null input. The transformed map might contain null values, if the function sometimes gives a null result.
The returned map is not thread-safe or serializable, even if the underlying map is.
The function is applied lazily, invoked when needed. This is necessary
for the returned map to be a view, but it means that the function will be
applied many times for bulk operations like Map.containsValue(java.lang.Object) and
Map.toString(). For this to perform well, function should
be fast. To avoid lazy evaluation when the returned map doesn't need to be
a view, copy the returned map into a new map of your choosing.
@Beta
public static <K,V1,V2> SortedMap<K,V2> transformValues(SortedMap<K,V1> fromMap,
Function<? super V1,V2> function)
SortedMap<String, Integer> map = ImmutableSortedMap.of("a", 4, "b", 9);
Function<Integer, Double> sqrt =
new Function<Integer, Double>() {
public Double apply(Integer in) {
return Math.sqrt((int) in);
}
};
SortedMap<String, Double> transformed =
Maps.transformSortedValues(map, sqrt);
System.out.println(transformed);
... prints {a=2.0, b=3.0}.
Changes in the underlying map are reflected in this view. Conversely, this view supports removal operations, and these are reflected in the underlying map.
It's acceptable for the underlying map to contain null keys, and even null values provided that the function is capable of accepting null input. The transformed map might contain null values, if the function sometimes gives a null result.
The returned map is not thread-safe or serializable, even if the underlying map is.
The function is applied lazily, invoked when needed. This is necessary
for the returned map to be a view, but it means that the function will be
applied many times for bulk operations like Map.containsValue(java.lang.Object) and
Map.toString(). For this to perform well, function should
be fast. To avoid lazy evaluation when the returned map doesn't need to be
a view, copy the returned map into a new map of your choosing.
public static <K,V1,V2> Map<K,V2> transformEntries(Map<K,V1> fromMap,
Maps.EntryTransformer<? super K,? super V1,V2> transformer)
transformValues(java.util.Map, com.google.common.base.Function super V1, V2>) , this method's
entry-transformation logic may depend on the key as well as the value.
All other properties of the transformed map, such as iteration order, are left intact. For example, the code:
Map<String, Boolean> options =
ImmutableMap.of("verbose", true, "sort", false);
EntryTransformer<String, Boolean, String> flagPrefixer =
new EntryTransformer<String, Boolean, String>() {
public String transformEntry(String key, Boolean value) {
return value ? key : "no" + key;
}
};
Map<String, String> transformed =
Maps.transformEntries(options, flagPrefixer);
System.out.println(transformed);
... prints {verbose=verbose, sort=nosort}.
Changes in the underlying map are reflected in this view. Conversely, this view supports removal operations, and these are reflected in the underlying map.
It's acceptable for the underlying map to contain null keys and null values provided that the transformer is capable of accepting null inputs. The transformed map might contain null values if the transformer sometimes gives a null result.
The returned map is not thread-safe or serializable, even if the underlying map is.
The transformer is applied lazily, invoked when needed. This is
necessary for the returned map to be a view, but it means that the
transformer will be applied many times for bulk operations like Map.containsValue(java.lang.Object) and Object.toString(). For this to perform well,
transformer should be fast. To avoid lazy evaluation when the
returned map doesn't need to be a view, copy the returned map into a new
map of your choosing.
Warning: This method assumes that for any instance k of
EntryTransformer key type K, k.equals(k2) implies
that k2 is also of type K. Using an EntryTransformer key type for which this may not hold, such as ArrayList, may risk a ClassCastException when calling methods on
the transformed map.
@Beta
public static <K,V1,V2> SortedMap<K,V2> transformEntries(SortedMap<K,V1> fromMap,
Maps.EntryTransformer<? super K,? super V1,V2> transformer)
transformValues(java.util.Map, com.google.common.base.Function super V1, V2>) , this
method's entry-transformation logic may depend on the key as well as the
value.
All other properties of the transformed map, such as iteration order, are left intact. For example, the code:
Map<String, Boolean> options =
ImmutableSortedMap.of("verbose", true, "sort", false);
EntryTransformer<String, Boolean, String> flagPrefixer =
new EntryTransformer<String, Boolean, String>() {
public String transformEntry(String key, Boolean value) {
return value ? key : "yes" + key;
}
};
SortedMap<String, String> transformed =
LabsMaps.transformSortedEntries(options, flagPrefixer);
System.out.println(transformed);
... prints {sort=yessort, verbose=verbose}.
Changes in the underlying map are reflected in this view. Conversely, this view supports removal operations, and these are reflected in the underlying map.
It's acceptable for the underlying map to contain null keys and null values provided that the transformer is capable of accepting null inputs. The transformed map might contain null values if the transformer sometimes gives a null result.
The returned map is not thread-safe or serializable, even if the underlying map is.
The transformer is applied lazily, invoked when needed. This is
necessary for the returned map to be a view, but it means that the
transformer will be applied many times for bulk operations like Map.containsValue(java.lang.Object) and Object.toString(). For this to perform well,
transformer should be fast. To avoid lazy evaluation when the
returned map doesn't need to be a view, copy the returned map into a new
map of your choosing.
Warning: This method assumes that for any instance k of
EntryTransformer key type K, k.equals(k2) implies
that k2 is also of type K. Using an EntryTransformer key type for which this may not hold, such as ArrayList, may risk a ClassCastException when calling methods on
the transformed map.
public static <K,V> Map<K,V> filterKeys(Map<K,V> unfiltered,
Predicate<? super K> keyPredicate)
unfiltered whose keys
satisfy a predicate. The returned map is a live view of unfiltered;
changes to one affect the other.
The resulting map's keySet(), entrySet(), and values() views have iterators that don't support remove(), but all
other methods are supported by the map and its views. When given a key that
doesn't satisfy the predicate, the map's put() and putAll()
methods throw an IllegalArgumentException.
When methods such as removeAll() and clear() are called
on the filtered map or its views, only mappings whose keys satisfy the
filter will be removed from the underlying map.
The returned map isn't threadsafe or serializable, even if unfiltered is.
Many of the filtered map's methods, such as size(),
iterate across every key/value mapping in the underlying map and determine
which satisfy the filter. When a live view is not needed, it may be
faster to copy the filtered map and use the copy.
Warning: keyPredicate must be consistent with
equals, as documented at Predicate.apply(T). Do not provide a
predicate such as Predicates.instanceOf(ArrayList.class), which is
inconsistent with equals.
@Beta
public static <K,V> SortedMap<K,V> filterKeys(SortedMap<K,V> unfiltered,
Predicate<? super K> keyPredicate)
unfiltered whose
keys satisfy a predicate. The returned map is a live view of unfiltered; changes to one affect the other.
The resulting map's keySet(), entrySet(), and values() views have iterators that don't support remove(), but all
other methods are supported by the map and its views. When given a key that
doesn't satisfy the predicate, the map's put() and putAll()
methods throw an IllegalArgumentException.
When methods such as removeAll() and clear() are called
on the filtered map or its views, only mappings whose keys satisfy the
filter will be removed from the underlying map.
The returned map isn't threadsafe or serializable, even if unfiltered is.
Many of the filtered map's methods, such as size(),
iterate across every key/value mapping in the underlying map and determine
which satisfy the filter. When a live view is not needed, it may be
faster to copy the filtered map and use the copy.
Warning: keyPredicate must be consistent with
equals, as documented at Predicate.apply(T). Do not provide a
predicate such as Predicates.instanceOf(ArrayList.class), which is
inconsistent with equals.
public static <K,V> Map<K,V> filterValues(Map<K,V> unfiltered,
Predicate<? super V> valuePredicate)
unfiltered whose values
satisfy a predicate. The returned map is a live view of unfiltered;
changes to one affect the other.
The resulting map's keySet(), entrySet(), and values() views have iterators that don't support remove(), but all
other methods are supported by the map and its views. When given a value
that doesn't satisfy the predicate, the map's put(), putAll(), and Map.Entry.setValue(V) methods throw an IllegalArgumentException.
When methods such as removeAll() and clear() are called
on the filtered map or its views, only mappings whose values satisfy the
filter will be removed from the underlying map.
The returned map isn't threadsafe or serializable, even if unfiltered is.
Many of the filtered map's methods, such as size(),
iterate across every key/value mapping in the underlying map and determine
which satisfy the filter. When a live view is not needed, it may be
faster to copy the filtered map and use the copy.
Warning: valuePredicate must be consistent with
equals, as documented at Predicate.apply(T). Do not provide a
predicate such as Predicates.instanceOf(ArrayList.class), which is
inconsistent with equals.
@Beta
public static <K,V> SortedMap<K,V> filterValues(SortedMap<K,V> unfiltered,
Predicate<? super V> valuePredicate)
unfiltered whose
values satisfy a predicate. The returned map is a live view of unfiltered; changes to one affect the other.
The resulting map's keySet(), entrySet(), and values() views have iterators that don't support remove(), but all
other methods are supported by the map and its views. When given a value
that doesn't satisfy the predicate, the map's put(), putAll(), and Map.Entry.setValue(V) methods throw an IllegalArgumentException.
When methods such as removeAll() and clear() are called
on the filtered map or its views, only mappings whose values satisfy the
filter will be removed from the underlying map.
The returned map isn't threadsafe or serializable, even if unfiltered is.
Many of the filtered map's methods, such as size(),
iterate across every key/value mapping in the underlying map and determine
which satisfy the filter. When a live view is not needed, it may be
faster to copy the filtered map and use the copy.
Warning: valuePredicate must be consistent with
equals, as documented at Predicate.apply(T). Do not provide a
predicate such as Predicates.instanceOf(ArrayList.class), which is
inconsistent with equals.
public static <K,V> Map<K,V> filterEntries(Map<K,V> unfiltered,
Predicate<? super Map.Entry<K,V>> entryPredicate)
unfiltered that satisfy a
predicate. The returned map is a live view of unfiltered; changes
to one affect the other.
The resulting map's keySet(), entrySet(), and values() views have iterators that don't support remove(), but all
other methods are supported by the map and its views. When given a
key/value pair that doesn't satisfy the predicate, the map's put()
and putAll() methods throw an IllegalArgumentException.
Similarly, the map's entries have a Map.Entry.setValue(V) method that
throws an IllegalArgumentException when the existing key and the
provided value don't satisfy the predicate.
When methods such as removeAll() and clear() are called
on the filtered map or its views, only mappings that satisfy the filter
will be removed from the underlying map.
The returned map isn't threadsafe or serializable, even if unfiltered is.
Many of the filtered map's methods, such as size(),
iterate across every key/value mapping in the underlying map and determine
which satisfy the filter. When a live view is not needed, it may be
faster to copy the filtered map and use the copy.
Warning: entryPredicate must be consistent with
equals, as documented at Predicate.apply(T).
@Beta
public static <K,V> SortedMap<K,V> filterEntries(SortedMap<K,V> unfiltered,
Predicate<? super Map.Entry<K,V>> entryPredicate)
unfiltered that
satisfy a predicate. The returned map is a live view of unfiltered;
changes to one affect the other.
The resulting map's keySet(), entrySet(), and values() views have iterators that don't support remove(), but all
other methods are supported by the map and its views. When given a
key/value pair that doesn't satisfy the predicate, the map's put()
and putAll() methods throw an IllegalArgumentException.
Similarly, the map's entries have a Map.Entry.setValue(V) method that
throws an IllegalArgumentException when the existing key and the
provided value don't satisfy the predicate.
When methods such as removeAll() and clear() are called
on the filtered map or its views, only mappings that satisfy the filter
will be removed from the underlying map.
The returned map isn't threadsafe or serializable, even if unfiltered is.
Many of the filtered map's methods, such as size(),
iterate across every key/value mapping in the underlying map and determine
which satisfy the filter. When a live view is not needed, it may be
faster to copy the filtered map and use the copy.
Warning: entryPredicate must be consistent with
equals, as documented at Predicate.apply(T).
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||