|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
Iterator
interface, to make this interface easier to implement for certain types of
data sources.element to the ImmutableList.
elements to the ImmutableList.
element to the ImmutableMultiset.
elements to the ImmutableMultiset.
element to the ImmutableSet.
elements to the ImmutableSet,
ignoring duplicate elements (only the first duplicate element is added).
element to the ImmutableSortedSet.
elements to the ImmutableSortedSet,
ignoring duplicate elements (only the first duplicate element is added).
elements to the ImmutableList.
elements to the ImmutableList.
elements to the ImmutableMultiset.
elements to the ImmutableMultiset.
elements to the ImmutableSet,
ignoring duplicate elements (only the first duplicate element is added).
elements to the ImmutableSet,
ignoring duplicate elements (only the first duplicate element is added).
elements to the ImmutableSortedSet,
ignoring duplicate elements (only the first duplicate element is added).
elements to the ImmutableSortedSet,
ignoring duplicate elements (only the first duplicate element is added).
iterable to collection.
iterator to collection.
ImmutableMultiset.
true if every element in iterable satisfies the
predicate.
true if every element returned by iterator
satisfies the given predicate.
true if one or more elements in iterable satisfy
the predicate.
true if one or more elements returned by iterator
satisfy the given predicate.
compare(a,
b) == 0 implies a == b (identity equality).
true if there are no differences between the two maps;
that is, if the maps are equal.
Multimap that uses an ArrayList to store
the values for a given key.Iterator to the Enumeration interface.
Searches
sortedList for key using the binary search algorithm.
ImmutableList based on the contents of
the Builder.
ImmutableMultiset based on the contents
of the Builder.
ImmutableSet based on the contents of
the Builder.
ImmutableSortedSet based on the contents
of the Builder and its comparator.
ImmutableSetMultimap.Builder.
RuntimeException if the specified element is
illegal.
RuntimeException if the specified key or value is
illegal.
Collection instances.Ordering.natural() when the natural ordering of the keys is used.
Ordering.natural() when the natural ordering of the
elements is used.
Comparable.compareTo(T), if the result of this comparison chain
has not already been determined.
int values as specified by Ints.compare(int, int),
if the result of this comparison chain has not already been
determined.
long values as specified by Longs.compare(long, long),
if the result of this comparison chain has not already been
determined.
float values as specified by Float.compare(float, float), if the result of this comparison chain has not
already been determined.
double values as specified by Double.compare(double, double), if the result of this comparison chain has not
already been determined.
boolean values as specified by Booleans.compare(boolean, boolean), if the result of this comparison chain has not
already been determined.
EnumSet consisting of all enum values that are not in
the specified collection.
EnumSet consisting of all enum values that are not in
the specified collection.
this, but which
in the event of a "tie", then delegates to secondaryComparator.
element to array.
element to array.
Multiset operations (exceptions where noted).Constraint interface.Iterator through Iterators.consumingIterator(Iterator).
iterator that removes each element
from the supplied iterator as it is returned.
true if iterable contains element; that is,
any object for which equals(element) is true.
true if iterator contains element.
true if this multiset contains at least one occurrence of
each element in the specified collection.
true if the multimap contains the specified key-value pair.
true if the multimap contains any values for the specified
key.
true if the multimap contains the specified value for any
key.
map.
map.
multimap.
map.
multimap.
multimap.
map, sorted
by the natural ordering of the keys.
map, with
keys sorted by the provided comparator.
Comparator.
Comparator.
Comparator.
element in this multiset.
ArrayListMultimap with the default initial
capacities.
ArrayListMultimap with enough capacity to hold
the specified numbers of keys and values without resizing.
ArrayListMultimap with the same mappings as the
specified multimap.
ConcurrentHashMultiset using the default
initial capacity, load factor, and concurrency settings.
ConcurrentHashMultiset containing the specified
elements, using the default initial capacity, load factor, and concurrency
settings.
EnumBiMap using the specified key and value
types.
EnumHashBiMap using the specified key type.
EnumMultiset.
EnumMultiset containing the specified elements.
HashBiMap with the default initial capacity
(16).
map.
HashMultimap with the default initial
capacities.
HashMultimap with enough capacity to hold the
specified numbers of keys and values without rehashing.
HashMultimap with the same mappings as the specified
multimap.
HashMultiset using the default initial
capacity.
HashMultiset with the specified expected
number of distinct elements.
HashMultiset containing the specified elements.
LinkedHashMultimap with the default initial
capacities.
LinkedHashMultimap with enough capacity to hold
the specified numbers of keys and values without rehashing.
LinkedHashMultimap with the same mappings as the
specified multimap.
LinkedHashMultiset using the default initial
capacity.
LinkedHashMultiset with the specified expected
number of distinct elements.
LinkedHashMultiset containing the specified elements.
LinkedListMultimap with the default initial
capacity.
LinkedListMultimap with enough capacity to hold
the specified number of keys without rehashing.
LinkedListMultimap with the same mappings as the
specified Multimap.
MutableClassToInstanceMap instance backed by a HashMap using the default initial capacity and load factor.
MutableClassToInstanceMap instance backed by a given
empty backingMap.
TreeMultimap ordered by the natural ordering of
its keys and values.
TreeMultimap instance using explicit comparators.
TreeMultimap, ordered by the natural ordering of its
keys and values, with the same mappings as the specified multimap.
iterable.
iterable.
computeNext must invoke this method when
there are no elements left in the iteration.
Multiset.Entry instances, each providing an element of the multiset and
the count of that element.
BiMap backed by two EnumMap instances.BiMap backed by an EnumMap instance for keys-to-values, and
a HashMap instance for values-to-keys.EnumMap.MapDifference.ValueDifference.leftValue()
values are equal and their MapDifference.ValueDifference.rightValue() values are also equal.
unfiltered that satisfy a predicate.
unfiltered that satisfy a predicate.
type in unfiltered.
unfiltered that satisfy a predicate.
type in unfiltered.
unfiltered that satisfy a predicate.
unfiltered that satisfy a
predicate.
unfiltered whose keys
satisfy a predicate.
unfiltered whose values
satisfy a predicate.
iterable that satisfies the given
predicate.
iterator that satisfies the given
predicate.
array in order.
put that silently removes any existing entry
with the value value before proceeding with the BiMap.put(K, V)
operation.
Enumeration to the Iterator interface.
comparator.
ImmutableMap<String, String> from a Properties
instance.
iterator position + 1 times, returning the
element at the positionth position.
null if no
entry for this class is present.
iterable.
iterable or defaultValue if
the iterable is empty.
iterator to the end, returning the last element.
iterator to the end, returning the last element or
defaultValue if the iterator is empty.
iterable.
iterable, or defaultValue if the iterable is empty.
iterator.
iterator, or defaultValue if the iterator is empty.
BiMap backed by two HashMap instances.Arrays.asList(leftValue(), rightValue()).hashCode().
Multimap using hash tables.HashMap.ImmutableSortedMap, consisting of the entries
whose keys are less than toKey.
BiMap with reliable user-specified iteration order.public
static final bimaps ("constant bimaps").ImmutableMap.List implementation.public static final lists ("constant lists").ListMultimap with reliable user-specified key and value
iteration order.ListMultimap instances, especially
public static final multimaps ("constant multimaps").Map with reliable user-specified iteration
order.public
static final maps ("constant maps").Multimap.public static final multimaps ("constant multimaps").public static final multisets ("constant multisets").Set with reliable, user-specified
iteration order.public static final sets ("constant sets").SetMultimap with reliable user-specified key and value
iteration order.SetMultimap instances, especially
public static final multimaps ("constant multimaps").SortedMap.public static final maps ("constant maps").SortedSet that stores its elements in a sorted array.public static final sets ("constant sets"), with a given
comparator.ImmutableMultimap that contains the results of
applying a specified function to each item in an Iterable of
values.
iterable of the first element that satisfies
the provided predicate, or -1 if the Iterable has no such
elements.
iterator of the first element that satisfies
the provided predicate, or -1 if the Iterator has no such
elements.
String.intern() for other immutable
types.Interner.source into dest, with
its key and value reversed.
true if the multimap contains no key-value pairs.
true if each element in iterable after the first is
greater than or equal to the element that preceded it, according to this
ordering.
true if each element in iterable after the first is
strictly greater than the element that preceded it, according to
this ordering.
Iterable.Iterator.limitSize elements of the given
iterable.
limitSize elements of the
given iterator.
Multimap that does not allow duplicate key-value
entries and that returns collections whose iterators follow the ordering in
which the data was added to the multimap.Multiset implementation with predictable iteration order.ListMultimap that supports deterministic
iteration order for both keys and values.Multimap that can hold duplicate key-value pairs and that maintains
the insertion ordering of values for a given key.List instances.Map or
Multimap.MapConstraint interface.ConcurrentMap builder, providing any combination of these
features: soft or weak keys, soft or weak values, timed expiration, and on-demand
computation of values.MapMaker instance with default settings,
including strong keys, strong values, and no automatic expiration.
Map instances.Map, but which may associate multiple
values with a single key.Multimap.Set, but
may have duplicate elements.Multiset instances.ArrayList instance.
ArrayList instance containing the given
elements.
ArrayList instance containing the given
elements.
ArrayList instance containing the given
elements.
ArrayList instance backed by an array of the
exact size specified; equivalent to
ArrayList.ArrayList(int).
ArrayList instance sized appropriately to hold an
estimated number of elements without resizing.
ConcurrentMap, which
supports all optional operations of the ConcurrentMap interface.
EnumMap instance.
EnumMap with the same mappings as the specified map.
EnumSet instance containing the given elements.
HashMap instance.
HashMap instance with the same mappings as
the specified map.
HashMap instance with enough capacity to hold the
specified number of elements without rehashing.
HashSet instance.
HashSet instance containing the given
elements in unspecified order.
HashSet instance containing the given
elements in unspecified order.
HashSet instance containing the given
elements in unspecified order.
HashSet instance with enough capacity to hold the
specified number of elements without rehashing.
IdentityHashMap instance.
LinkedHashMap
instance.
LinkedHashMap instance
with the same mappings as the specified map.
LinkedHashSet instance.
LinkedHashSet instance containing the
given elements in order.
LinkedList instance.
LinkedList instance containing the given elements.
ListMultimap that uses the provided map and factory.
Multimap that uses the provided map and factory.
SetMultimap that uses the provided map and factory.
SortedSetMultimap that uses the provided map and
factory.
TreeMap instance using the natural
ordering of its elements.
TreeMap instance with the same mappings as
the specified map and using the same ordering as the specified map.
TreeMap instance using the given
comparator.
TreeSet instance sorted by the
natural sort ordering of its elements.
TreeSet instance containing the given
elements sorted by their natural ordering.
TreeSet instance with the given
comparator.
null as less than all other values
and uses this to compare non-null values.
null as greater than all other
values and uses this ordering to compare non-null values.
ImmutableList.copyOf(Object[])
ImmutableSet.copyOf(Object[]).
ImmutableSortedSet.copyOf(Comparable[]).
F which orders elements by first applying
a function to them, then comparing those results using this.
PeekingIterator.peek().
PeekingIterator backed by the given iterator.
key with value in the built bimap.
key with value in the built map.
key with value in the built map.
key with value in the built map.
map's keys and values in the built map.
element, or
makes no change if this is not possible.
Ordering equivalent to
Collections.reverseOrder(Comparator).
element such that the ConcurrentHashMultiset.count(java.lang.Object)
of the element becomes count.
element to newCount, but
only if the count is currently oldCount.
Multiset.setCount(Object, int), provided that the element has the expected
current count.
Multimap that cannot hold duplicate key-value pairs.Set instances.value.
iterable.
iterator.
iterable that skips its first
numberToSkip elements.
next() on iterator, either numberToSkip times
or until hasNext() returns false, whichever comes first.
SoftReference (by default, strong references
are used).
SoftReference (by default, strong references
are used).
SetMultimap whose set of values for a given key are kept sorted;
that is, they comprise a SortedSet.fromIndex, inclusive, and toIndex, exclusive.
ImmutableSortedMap, consisting of the entries
whose keys ranges from fromKey, inclusive, to toKey,
exclusive.
ListMultimap backed by the
specified multimap.
SetMultimap backed by the
specified multimap.
SortedSetMultimap backed by
the specified multimap.
ImmutableSortedMap, consisting of the entries
whose keys are greater than or equals to fromKey.
toString method.
iterable, with the format
[e1, e2, ..., en].
iterator, with the format
[e1, e2, ..., en].
toString on the map returned by Multimap.asMap().
function to each element of
fromCollection.
function to each element of fromIterable.
function to each element of fromIterator.
function to each element of fromList.
Multimap whose keys and values are ordered by
their natural ordering or by supplied comparators.Comparator.ArrayListMultimap, if feasible.
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.
iterable.
iterator.
UnmodifiableIterator.remove().ListMultimap.
SetMultimap.
SortedSetMultimap.
toString().
null
indicating that natural ordering is used.
WeakReference (by default, strong references
are used).
WeakReference (by default, strong references
are used).
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||