@ParametersAreNonnullByDefault
See: Description
Interface | Description |
---|---|
BiMap<K,V> |
A bimap (or "bidirectional map") is a map that preserves the uniqueness of its values as well as
that of its keys.
|
ClassToInstanceMap<B> |
A map, each entry of which maps a Java raw type to an
instance of that type.
|
FilteredMultimap<K,V> |
An interface for all filtered multimap types.
|
FilteredSetMultimap<K,V> |
A supertype for filtered
SetMultimap implementations. |
Interner<E> |
Provides equivalent behavior to
String.intern() for other immutable types. |
LinkedHashMultimap.ValueSetLink<K,V> | |
ListMultimap<K,V> |
A
Multimap that can hold duplicate key-value pairs and that maintains the insertion
ordering of values for a given key. |
MapDifference<K,V> |
An object representing the differences between two maps.
|
MapDifference.ValueDifference<V> |
A difference between the mappings from two maps with the same key.
|
MapMakerInternalMap.InternalEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
An entry in a hash table of a
MapMakerInternalMap.Segment . |
MapMakerInternalMap.InternalEntryHelper<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>,S extends MapMakerInternalMap.Segment<K,V,E,S>> |
A helper object for operating on
MapMakerInternalMap.InternalEntry instances in a type-safe and efficient
manner. |
MapMakerInternalMap.StrongValueEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
Marker interface for
MapMakerInternalMap.InternalEntry implementations for strong values. |
MapMakerInternalMap.WeakValueEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
Marker interface for
MapMakerInternalMap.InternalEntry implementations for weak values. |
MapMakerInternalMap.WeakValueReference<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
A weakly referenced value that also has a reference to its containing entry.
|
Maps.EntryTransformer<K,V1,V2> |
A transformation of the value of a key-value pair, using both key and value as inputs.
|
Multimap<K,V> |
A collection that maps keys to values, similar to
Map , but in which each key may be
associated with multiple values. |
Multiset<E> |
A collection that supports order-independent equality, like
Set , but may have duplicate
elements. |
Multiset.Entry<E> |
An unmodifiable element-count pair for a multiset.
|
PeekingIterator<E> |
An iterator that supports a one-element lookahead while iterating.
|
RangeMap<K extends java.lang.Comparable,V> |
A mapping from disjoint nonempty ranges to non-null values.
|
RangeSet<C extends java.lang.Comparable> | |
RowSortedTable<R,C,V> |
Interface that extends
Table and whose rows are sorted. |
SetMultimap<K,V> |
A
Multimap that cannot hold duplicate key-value pairs. |
SortedIterable<T> |
An
Iterable whose elements are sorted relative to a Comparator , typically
provided at creation time. |
SortedMapDifference<K,V> |
An object representing the differences between two sorted maps.
|
SortedMultiset<E> |
A
Multiset which maintains the ordering of its elements, according to either their
natural order or an explicit Comparator . |
SortedMultisetBridge<E> |
Superinterface of
SortedMultiset to introduce a bridge method for elementSet() ,
to ensure binary compatibility with older Guava versions that specified elementSet() to
return SortedSet . |
SortedSetMultimap<K,V> |
A
SetMultimap whose set of values for a given key are kept sorted; that is, they comprise
a SortedSet . |
Streams.DoubleFunctionWithIndex<R> |
An analogue of
DoubleFunction also accepting an index. |
Streams.FunctionWithIndex<T,R> |
An analogue of
Function also accepting an index. |
Streams.IntFunctionWithIndex<R> |
An analogue of
IntFunction also accepting an index. |
Streams.LongFunctionWithIndex<R> |
An analogue of
LongFunction also accepting an index. |
Table<R,C,V> |
A collection that associates an ordered pair of keys, called a row key and a column key, with a
single value.
|
Table.Cell<R,C,V> |
Row key / column key / value triplet corresponding to a mapping in a table.
|
Class | Description |
---|---|
AbstractBiMap<K,V> |
A general-purpose bimap implementation using any two backing
Map instances. |
AbstractBiMap.Inverse<K,V> |
The inverse of any other
AbstractBiMap subclass. |
AbstractIndexedListIterator<E> |
This class provides a skeletal implementation of the
ListIterator interface across a
fixed number of elements that may be retrieved by position. |
AbstractIterator<T> |
This class provides a skeletal implementation of the
Iterator interface, to make this
interface easier to implement for certain types of data sources. |
AbstractListMultimap<K,V> |
Basic implementation of the
ListMultimap interface. |
AbstractMapBasedMultimap<K,V> |
Basic implementation of the
Multimap interface. |
AbstractMapBasedMultiset<E> |
Basic implementation of
Multiset<E> backed by an instance of Map<E, Count> . |
AbstractMapEntry<K,V> |
Implementation of the
equals , hashCode , and toString methods of Entry . |
AbstractMultimap<K,V> |
A skeleton
Multimap implementation, not necessarily in terms of a Map . |
AbstractMultiset<E> |
This class provides a skeletal implementation of the
Multiset interface. |
AbstractNavigableMap<K,V> |
Skeletal implementation of
NavigableMap . |
AbstractRangeSet<C extends java.lang.Comparable> |
A skeletal implementation of
RangeSet . |
AbstractSequentialIterator<T> |
This class provides a skeletal implementation of the
Iterator interface for sequences
whose next element can always be derived from the previous element. |
AbstractSetMultimap<K,V> |
Basic implementation of the
SetMultimap interface. |
AbstractSortedKeySortedSetMultimap<K,V> |
Basic implementation of a
SortedSetMultimap with a sorted key set. |
AbstractSortedMultiset<E> |
This class provides a skeletal implementation of the
SortedMultiset interface. |
AbstractSortedSetMultimap<K,V> |
Basic implementation of the
SortedSetMultimap interface. |
AbstractTable<R,C,V> |
Skeletal, implementation-agnostic implementation of the
Table interface. |
AllEqualOrdering |
An ordering that treats all references as equals, even nulls.
|
ArrayListMultimap<K,V> |
Implementation of
Multimap that uses an ArrayList to store the values for a given
key. |
ArrayListMultimapGwtSerializationDependencies<K,V> |
A dummy superclass to support GWT serialization of the element types of an
ArrayListMultimap . |
ArrayTable<R,C,V> |
Fixed-size
Table implementation backed by a two-dimensional array. |
ArrayTable.ArrayMap<K,V> | |
ByFunctionOrdering<F,T> |
An ordering that orders elements by applying an order to the result of a function on those
elements.
|
CartesianList<E> |
Implementation of
Lists.cartesianProduct(List) . |
CollectCollectors |
Collectors utilities for
common.collect internals. |
Collections2 |
Provides static methods for working with
Collection instances. |
Collections2.FilteredCollection<E> | |
Collections2.OrderedPermutationCollection<E> | |
Collections2.OrderedPermutationIterator<E> | |
Collections2.PermutationCollection<E> | |
Collections2.PermutationIterator<E> | |
Collections2.TransformedCollection<F,T> | |
CollectPreconditions |
Precondition checks useful in collection implementations.
|
CollectSpliterators |
Spliterator utilities for
common.collect internals. |
CompactHashMap<K,V> |
CompactHashMap is an implementation of a Map.
|
CompactHashSet<E> |
CompactHashSet is an implementation of a Set.
|
CompactLinkedHashMap<K,V> |
CompactLinkedHashMap is an implementation of a Map with insertion or LRU iteration order,
maintained with a doubly linked list through the entries.
|
CompactLinkedHashSet<E> |
CompactLinkedHashSet is an implementation of a Set, which a predictable iteration order that
matches the insertion order.
|
ComparatorOrdering<T> |
An ordering for a pre-existing comparator.
|
Comparators |
Provides static methods for working with
Comparator instances. |
ComparisonChain |
A utility for performing a chained comparison statement.
|
ComparisonChain.InactiveComparisonChain | |
CompoundOrdering<T> |
An ordering that tries several comparators in order.
|
ConcurrentHashMultiset<E> |
A multiset that supports concurrent modifications and that provides atomic versions of most
Multiset operations (exceptions where noted). |
ConcurrentHashMultiset.FieldSettersHolder | |
ConsumingQueueIterator<T> |
An Iterator implementation which draws elements from a queue, removing them from the queue as it
iterates.
|
ContiguousSet<C extends java.lang.Comparable> |
A sorted set of contiguous values in a given
DiscreteDomain . |
Count |
A mutable value of type
int , for multisets to use in tracking counts of values. |
Cut<C extends java.lang.Comparable> |
Implementation detail for the internal structure of
Range instances. |
Cut.AboveAll | |
Cut.AboveValue<C extends java.lang.Comparable> | |
Cut.BelowAll | |
Cut.BelowValue<C extends java.lang.Comparable> | |
DenseImmutableTable<R,C,V> |
A
RegularImmutableTable optimized for dense data. |
DenseImmutableTable.ImmutableArrayMap<K,V> |
An immutable map implementation backed by an indexed nullable array.
|
DescendingImmutableSortedMultiset<E> |
A descending wrapper around an
ImmutableSortedMultiset |
DescendingImmutableSortedSet<E> |
Skeletal implementation of
ImmutableSortedSet.descendingSet() . |
DescendingMultiset<E> |
A skeleton implementation of a descending multiset.
|
DiscreteDomain<C extends java.lang.Comparable> |
A descriptor for a discrete
Comparable domain such as all Integer
instances. |
DiscreteDomain.BigIntegerDomain | |
DiscreteDomain.IntegerDomain | |
DiscreteDomain.LongDomain | |
EmptyContiguousSet<C extends java.lang.Comparable> |
An empty contiguous set.
|
EmptyContiguousSet.SerializedForm<C extends java.lang.Comparable> | |
EmptyImmutableListMultimap |
Implementation of
ImmutableListMultimap with no entries. |
EmptyImmutableSetMultimap |
Implementation of
ImmutableListMultimap with no entries. |
EnumBiMap<K extends java.lang.Enum<K>,V extends java.lang.Enum<V>> |
A
BiMap backed by two EnumMap instances. |
EnumHashBiMap<K extends java.lang.Enum<K>,V> |
A
BiMap backed by an EnumMap instance for keys-to-values, and a HashMap
instance for values-to-keys. |
EnumMultiset<E extends java.lang.Enum<E>> |
Multiset implementation specialized for enum elements, supporting all single-element operations
in O(1).
|
EvictingQueue<E> |
A non-blocking queue which automatically evicts elements from the head of the queue when
attempting to add new elements onto the queue and it is full.
|
ExplicitOrdering<T> |
An ordering that compares objects according to a given order.
|
FilteredEntryMultimap<K,V> |
Implementation of
Multimaps.filterEntries(Multimap, Predicate) . |
FilteredEntrySetMultimap<K,V> |
Implementation of
Multimaps.filterEntries(SetMultimap, Predicate) . |
FilteredKeyListMultimap<K,V> |
Implementation of
Multimaps.filterKeys(ListMultimap, Predicate) . |
FilteredKeyMultimap<K,V> |
Implementation of
Multimaps.filterKeys(Multimap, Predicate) . |
FilteredKeyMultimap.AddRejectingList<K,V> | |
FilteredKeyMultimap.AddRejectingSet<K,V> | |
FilteredKeySetMultimap<K,V> |
Implementation of
Multimaps.filterKeys(SetMultimap, Predicate) . |
FilteredMultimapValues<K,V> |
Implementation for
Multimap.values() . |
FluentIterable<E> |
A discouraged (but not deprecated) precursor to Java's superior
Stream library. |
FluentIterable.FromIterableFunction<E> |
Function that transforms
Iterable<E> into a fluent iterable. |
ForwardingBlockingDeque<E> | Deprecated
This class has moved to
com.google.common.util.concurrent . |
ForwardingCollection<E> |
A collection which forwards all its method calls to another collection.
|
ForwardingConcurrentMap<K,V> |
A concurrent map which forwards all its method calls to another concurrent map.
|
ForwardingDeque<E> |
A deque which forwards all its method calls to another deque.
|
ForwardingImmutableCollection |
Dummy class that makes the GWT serialization policy happy.
|
ForwardingImmutableList<E> |
Unused stub class, unreferenced under Java and manually emulated under GWT.
|
ForwardingImmutableMap<K,V> |
Unused stub class, unreferenced under Java and manually emulated under GWT.
|
ForwardingImmutableSet<E> |
Unused stub class, unreferenced under Java and manually emulated under GWT.
|
ForwardingIterator<T> |
An iterator which forwards all its method calls to another iterator.
|
ForwardingList<E> |
A list which forwards all its method calls to another list.
|
ForwardingListIterator<E> |
A list iterator which forwards all its method calls to another list iterator.
|
ForwardingListMultimap<K,V> |
A list multimap which forwards all its method calls to another list multimap.
|
ForwardingMap<K,V> |
A map which forwards all its method calls to another map.
|
ForwardingMapEntry<K,V> |
A map entry which forwards all its method calls to another map entry.
|
ForwardingMultimap<K,V> |
A multimap which forwards all its method calls to another multimap.
|
ForwardingMultiset<E> |
A multiset which forwards all its method calls to another multiset.
|
ForwardingNavigableMap<K,V> |
A navigable map which forwards all its method calls to another navigable map.
|
ForwardingNavigableSet<E> |
A navigable set which forwards all its method calls to another navigable set.
|
ForwardingObject |
An abstract base class for implementing the decorator pattern.
|
ForwardingQueue<E> |
A queue which forwards all its method calls to another queue.
|
ForwardingSet<E> |
A set which forwards all its method calls to another set.
|
ForwardingSetMultimap<K,V> |
A set multimap which forwards all its method calls to another set multimap.
|
ForwardingSortedMap<K,V> |
A sorted map which forwards all its method calls to another sorted map.
|
ForwardingSortedMultiset<E> |
A sorted multiset which forwards all its method calls to another sorted multiset.
|
ForwardingSortedSet<E> |
A sorted set which forwards all its method calls to another sorted set.
|
ForwardingSortedSetMultimap<K,V> |
A sorted set multimap which forwards all its method calls to another sorted set multimap.
|
ForwardingTable<R,C,V> |
A table which forwards all its method calls to another table.
|
GeneralRange<T> |
A generalized interval on any ordering, for internal use.
|
HashBasedTable<R,C,V> |
Implementation of
Table using linked hash tables. |
HashBasedTable.Factory<C,V> | |
HashBiMap<K,V> |
A
BiMap backed by two hash tables. |
HashBiMap.BiEntry<K,V> | |
HashBiMap.InverseSerializedForm<K,V> | |
Hashing |
Static methods for implementing hash-based collections.
|
HashMultimap<K,V> |
Implementation of
Multimap using hash tables. |
HashMultimapGwtSerializationDependencies<K,V> |
A dummy superclass to support GWT serialization of the element types of a
HashMultimap . |
HashMultiset<E> |
Multiset implementation backed by a
HashMap . |
ImmutableAsList<E> |
List returned by
ImmutableCollection.asList() that delegates contains checks to the
backing collection. |
ImmutableAsList.SerializedForm |
Serialized form that leads to the same performance as the original list.
|
ImmutableBiMap<K,V> |
A
BiMap whose contents will never change, with many other important properties detailed
at ImmutableCollection . |
ImmutableBiMap.Builder<K,V> |
A builder for creating immutable bimap instances, especially
public static final bimaps
("constant bimaps"). |
ImmutableBiMap.SerializedForm |
Serialized type for all ImmutableBiMap instances.
|
ImmutableBiMapFauxverideShim<K,V> |
"Overrides" the
ImmutableMap static methods that lack ImmutableBiMap equivalents
with deprecated, exception-throwing versions. |
ImmutableClassToInstanceMap<B> |
A
ClassToInstanceMap whose contents will never change, with many other important
properties detailed at ImmutableCollection . |
ImmutableClassToInstanceMap.Builder<B> |
A builder for creating immutable class-to-instance maps.
|
ImmutableCollection<E> |
A
Collection whose contents will never change, and which offers a few additional
guarantees detailed below. |
ImmutableCollection.Builder<E> |
Abstract base class for builders of
ImmutableCollection types. |
ImmutableEntry<K,V> | |
ImmutableEnumMap<K extends java.lang.Enum<K>,V> |
Implementation of
ImmutableMap backed by a non-empty EnumMap . |
ImmutableEnumMap.EnumSerializedForm<K extends java.lang.Enum<K>,V> | |
ImmutableEnumSet<E extends java.lang.Enum<E>> |
Implementation of
ImmutableSet backed by a non-empty EnumSet . |
ImmutableEnumSet.EnumSerializedForm<E extends java.lang.Enum<E>> | |
ImmutableList<E> |
A
List whose contents will never change, with many other important properties detailed at
ImmutableCollection . |
ImmutableList.Builder<E> |
A builder for creating immutable list instances, especially
public static final lists
("constant lists"). |
ImmutableList.ReverseImmutableList<E> | |
ImmutableList.SerializedForm | |
ImmutableListMultimap<K,V> |
A
ListMultimap whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableListMultimap.Builder<K,V> |
A builder for creating immutable
ListMultimap instances, especially public
static final multimaps ("constant multimaps"). |
ImmutableMap<K,V> |
A
Map whose contents will never change, with many other important properties detailed at
ImmutableCollection . |
ImmutableMap.Builder<K,V> |
A builder for creating immutable map instances, especially
public static final maps
("constant maps"). |
ImmutableMap.IteratorBasedImmutableMap<K,V> | |
ImmutableMap.SerializedForm |
Serialized type for all ImmutableMap instances.
|
ImmutableMapEntry<K,V> |
Implementation of
Entry for ImmutableMap that adds extra methods to traverse hash
buckets for the key and the value. |
ImmutableMapEntry.NonTerminalImmutableBiMapEntry<K,V> | |
ImmutableMapEntry.NonTerminalImmutableMapEntry<K,V> | |
ImmutableMapEntrySet<K,V> |
entrySet() implementation for ImmutableMap . |
ImmutableMapEntrySet.EntrySetSerializedForm<K,V> | |
ImmutableMapEntrySet.RegularEntrySet<K,V> | |
ImmutableMapKeySet<K,V> |
keySet() implementation for ImmutableMap . |
ImmutableMapKeySet.KeySetSerializedForm<K> | |
ImmutableMapValues<K,V> |
values() implementation for ImmutableMap . |
ImmutableMapValues.SerializedForm<V> | |
ImmutableMultimap<K,V> |
A
Multimap whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableMultimap.Builder<K,V> |
A builder for creating immutable multimap instances, especially
public static final
multimaps ("constant multimaps"). |
ImmutableMultimap.EntryCollection<K,V> | |
ImmutableMultimap.FieldSettersHolder | |
ImmutableMultimap.KeysSerializedForm | |
ImmutableMultimap.Values<K,V> | |
ImmutableMultiset<E> |
A
Multiset whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableMultiset.Builder<E> |
A builder for creating immutable multiset instances, especially
public static final
multisets ("constant multisets"). |
ImmutableMultiset.ElementSet<E> | |
ImmutableMultiset.EntrySetSerializedForm<E> | |
ImmutableMultiset.SerializedForm | |
ImmutableMultisetGwtSerializationDependencies<E> |
A dummy superclass to support GWT serialization of the element type of an
ImmutableMultiset . |
ImmutableRangeMap<K extends java.lang.Comparable<?>,V> |
A
RangeMap whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableRangeMap.Builder<K extends java.lang.Comparable<?>,V> |
A builder for immutable range maps.
|
ImmutableRangeMap.SerializedForm<K extends java.lang.Comparable<?>,V> |
This class is used to serialize ImmutableRangeMap instances.
|
ImmutableRangeSet<C extends java.lang.Comparable> |
A
RangeSet whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableRangeSet.AsSetSerializedForm<C extends java.lang.Comparable> | |
ImmutableRangeSet.Builder<C extends java.lang.Comparable<?>> |
A builder for immutable range sets.
|
ImmutableRangeSet.SerializedForm<C extends java.lang.Comparable> | |
ImmutableSet<E> |
A
Set whose contents will never change, with many other important properties detailed at
ImmutableCollection . |
ImmutableSet.Builder<E> |
A builder for creating
ImmutableSet instances. |
ImmutableSet.Indexed<E> | |
ImmutableSet.JdkBackedSetBuilderImpl<E> |
SetBuilderImpl version that uses a JDK HashSet, which has built in hash flooding protection.
|
ImmutableSet.RegularSetBuilderImpl<E> |
Default implementation of the guts of ImmutableSet.Builder, creating an open-addressed hash
table and deduplicating elements as they come, so it only allocates O(max(distinct,
expectedCapacity)) rather than O(calls to add).
|
ImmutableSet.SerializedForm | |
ImmutableSet.SetBuilderImpl<E> |
Swappable internal implementation of an ImmutableSet.Builder.
|
ImmutableSetMultimap<K,V> |
A
SetMultimap whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableSetMultimap.Builder<K,V> |
A builder for creating immutable
SetMultimap instances, especially public static
final multimaps ("constant multimaps"). |
ImmutableSetMultimap.EntrySet<K,V> | |
ImmutableSetMultimap.SetFieldSettersHolder | |
ImmutableSortedAsList<E> |
List returned by
ImmutableSortedSet.asList() when the set isn't empty. |
ImmutableSortedMap<K,V> |
A
NavigableMap whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableSortedMap.Builder<K,V> |
A builder for creating immutable sorted map instances, especially
public static final
maps ("constant maps"). |
ImmutableSortedMap.SerializedForm |
Serialized type for all ImmutableSortedMap instances.
|
ImmutableSortedMapFauxverideShim<K,V> |
"Overrides" the
ImmutableMap static methods that lack ImmutableSortedMap
equivalents with deprecated, exception-throwing versions. |
ImmutableSortedMultiset<E> |
A
SortedMultiset whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableSortedMultiset.Builder<E> |
A builder for creating immutable multiset instances, especially
public static final
multisets ("constant multisets"). |
ImmutableSortedMultiset.SerializedForm<E> | |
ImmutableSortedMultisetFauxverideShim<E> |
"Overrides" the
ImmutableMultiset static methods that lack ImmutableSortedMultiset equivalents with deprecated, exception-throwing versions. |
ImmutableSortedSet<E> |
A
NavigableSet whose contents will never change, with many other important properties
detailed at ImmutableCollection . |
ImmutableSortedSet.Builder<E> |
A builder for creating immutable sorted set instances, especially
public static final
sets ("constant sets"), with a given comparator. |
ImmutableSortedSet.SerializedForm<E> | |
ImmutableSortedSetFauxverideShim<E> |
"Overrides" the
ImmutableSet static methods that lack ImmutableSortedSet
equivalents with deprecated, exception-throwing versions. |
ImmutableTable<R,C,V> |
A
Table whose contents will never change, with many other important properties detailed
at ImmutableCollection . |
ImmutableTable.Builder<R,C,V> |
A builder for creating immutable table instances, especially
public static final tables
("constant tables"). |
ImmutableTable.CollectorState<R,C,V> | |
ImmutableTable.MutableCell<R,C,V> | |
ImmutableTable.SerializedForm |
Serialized type for all ImmutableTable instances.
|
IndexedImmutableSet<E> | |
Interners |
Contains static methods pertaining to instances of
Interner . |
Interners.InternerBuilder |
Builder for
Interner instances. |
Interners.InternerFunction<E> | |
Interners.InternerImpl<E> | |
Iterables |
An assortment of mainly legacy static utility methods that operate on or return objects of type
Iterable . |
Iterables.UnmodifiableIterable<T> | |
Iterators |
This class contains static utility methods that operate on or return objects of type
Iterator . |
Iterators.ArrayItr<T> | |
Iterators.ConcatenatedIterator<T> | |
Iterators.MergingIterator<T> |
An iterator that performs a lazy N-way merge, calculating the next value each time the iterator
is polled.
|
Iterators.PeekingImpl<E> |
Implementation of PeekingIterator that avoids peeking unless necessary.
|
JdkBackedImmutableBiMap<K,V> |
Implementation of ImmutableBiMap backed by a pair of JDK HashMaps, which have smartness
protecting against hash flooding.
|
JdkBackedImmutableMap<K,V> |
Implementation of ImmutableMap backed by a JDK HashMap, which has smartness protecting against
hash flooding.
|
JdkBackedImmutableMultiset<E> |
An implementation of ImmutableMultiset backed by a JDK Map and a list of entries.
|
JdkBackedImmutableSet<E> |
ImmutableSet implementation backed by a JDK HashSet, used to defend against apparent hash
flooding.
|
LexicographicalOrdering<T> |
An ordering which sorts iterables by comparing corresponding elements pairwise.
|
LinkedHashMultimap<K,V> |
Implementation of
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. |
LinkedHashMultimap.ValueEntry<K,V> |
LinkedHashMultimap entries are in no less than three coexisting linked lists: a bucket in the
hash table for a
Set<V> associated with a key, the linked list of insertion-ordered
entries in that Set<V> , and the linked list of entries in the LinkedHashMultimap as a
whole. |
LinkedHashMultimapGwtSerializationDependencies<K,V> |
A dummy superclass to support GWT serialization of the element types of a
LinkedHashMultimap . |
LinkedHashMultiset<E> |
A
Multiset implementation with predictable iteration order. |
LinkedListMultimap<K,V> |
An implementation of
ListMultimap that supports deterministic iteration order for both
keys and values. |
LinkedListMultimap.KeyList<K,V> | |
LinkedListMultimap.Node<K,V> | |
Lists |
Static utility methods pertaining to
List instances. |
Lists.AbstractListWrapper<E> | |
Lists.CharSequenceAsList | |
Lists.OnePlusArrayList<E> | |
Lists.Partition<T> | |
Lists.RandomAccessListWrapper<E> | |
Lists.RandomAccessPartition<T> | |
Lists.RandomAccessReverseList<T> | |
Lists.ReverseList<T> | |
Lists.StringAsImmutableList | |
Lists.TransformingRandomAccessList<F,T> |
Implementation of a transforming random access list.
|
Lists.TransformingSequentialList<F,T> |
Implementation of a sequential transforming list.
|
Lists.TwoPlusArrayList<E> | |
MapMaker |
A builder of
ConcurrentMap instances that can have keys or values automatically wrapped
in weak references. |
MapMakerInternalMap<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>,S extends MapMakerInternalMap.Segment<K,V,E,S>> |
The concurrent hash map implementation built by
MapMaker . |
MapMakerInternalMap.AbstractSerializationProxy<K,V> |
The actual object that gets serialized.
|
MapMakerInternalMap.AbstractStrongKeyEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
Base class for
MapMakerInternalMap.InternalEntry implementations for strong keys. |
MapMakerInternalMap.AbstractWeakKeyEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
Base class for
MapMakerInternalMap.InternalEntry implementations for weak keys. |
MapMakerInternalMap.CleanupMapTask | |
MapMakerInternalMap.DummyInternalEntry |
A dummy implementation of
MapMakerInternalMap.InternalEntry , solely for use in the type signature of MapMakerInternalMap.UNSET_WEAK_VALUE_REFERENCE below. |
MapMakerInternalMap.SafeToArraySet<E> | |
MapMakerInternalMap.Segment<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>,S extends MapMakerInternalMap.Segment<K,V,E,S>> |
Segments are specialized versions of hash tables.
|
MapMakerInternalMap.SerializationProxy<K,V> |
The actual object that gets serialized.
|
MapMakerInternalMap.StrongKeyDummyValueEntry<K> |
Concrete implementation of
MapMakerInternalMap.InternalEntry for strong keys and MapMaker.Dummy values. |
MapMakerInternalMap.StrongKeyDummyValueEntry.Helper<K> |
Concrete implementation of
MapMakerInternalMap.InternalEntryHelper for strong keys and MapMaker.Dummy
values. |
MapMakerInternalMap.StrongKeyDummyValueSegment<K> |
Concrete implementation of
MapMakerInternalMap.Segment for strong keys and MapMaker.Dummy values. |
MapMakerInternalMap.StrongKeyStrongValueEntry<K,V> |
Concrete implementation of
MapMakerInternalMap.InternalEntry for strong keys and strong values. |
MapMakerInternalMap.StrongKeyStrongValueEntry.Helper<K,V> |
Concrete implementation of
MapMakerInternalMap.InternalEntryHelper for strong keys and strong values. |
MapMakerInternalMap.StrongKeyStrongValueSegment<K,V> |
Concrete implementation of
MapMakerInternalMap.Segment for strong keys and strong values. |
MapMakerInternalMap.StrongKeyWeakValueEntry<K,V> |
Concrete implementation of
MapMakerInternalMap.InternalEntry for strong keys and weak values. |
MapMakerInternalMap.StrongKeyWeakValueEntry.Helper<K,V> |
Concrete implementation of
MapMakerInternalMap.InternalEntryHelper for strong keys and weak values. |
MapMakerInternalMap.StrongKeyWeakValueSegment<K,V> |
Concrete implementation of
MapMakerInternalMap.Segment for strong keys and weak values. |
MapMakerInternalMap.WeakKeyDummyValueEntry<K> |
Concrete implementation of
MapMakerInternalMap.InternalEntry for weak keys and MapMaker.Dummy values. |
MapMakerInternalMap.WeakKeyDummyValueEntry.Helper<K> |
Concrete implementation of
MapMakerInternalMap.InternalEntryHelper for weak keys and MapMaker.Dummy
values. |
MapMakerInternalMap.WeakKeyDummyValueSegment<K> |
Concrete implementation of
MapMakerInternalMap.Segment for weak keys and MapMaker.Dummy values. |
MapMakerInternalMap.WeakKeyStrongValueEntry<K,V> |
Concrete implementation of
MapMakerInternalMap.InternalEntry for weak keys and strong values. |
MapMakerInternalMap.WeakKeyStrongValueEntry.Helper<K,V> |
Concrete implementation of
MapMakerInternalMap.InternalEntryHelper for weak keys and strong values. |
MapMakerInternalMap.WeakKeyStrongValueSegment<K,V> |
Concrete implementation of
MapMakerInternalMap.Segment for weak keys and strong values. |
MapMakerInternalMap.WeakKeyWeakValueEntry<K,V> |
Concrete implementation of
MapMakerInternalMap.InternalEntry for weak keys and weak values. |
MapMakerInternalMap.WeakKeyWeakValueEntry.Helper<K,V> |
Concrete implementation of
MapMakerInternalMap.InternalEntryHelper for weak keys and weak values. |
MapMakerInternalMap.WeakKeyWeakValueSegment<K,V> |
Concrete implementation of
MapMakerInternalMap.Segment for weak keys and weak values. |
MapMakerInternalMap.WeakValueReferenceImpl<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
Concrete implementation of
MapMakerInternalMap.WeakValueReference . |
Maps | |
Maps.AbstractFilteredMap<K,V> | |
Maps.Accumulator<K extends java.lang.Enum<K>,V> | |
Maps.AsMapView<K,V> | |
Maps.BiMapConverter<A,B> | |
Maps.DescendingMap<K,V> | |
Maps.EntrySet<K,V> | |
Maps.FilteredEntryBiMap<K,V> | |
Maps.FilteredEntryMap<K,V> | |
Maps.FilteredEntryNavigableMap<K,V> | |
Maps.FilteredEntrySortedMap<K,V> | |
Maps.FilteredKeyMap<K,V> | |
Maps.FilteredMapValues<K,V> | |
Maps.IteratorBasedAbstractMap<K,V> | |
Maps.KeySet<K,V> | |
Maps.MapDifferenceImpl<K,V> | |
Maps.NavigableAsMapView<K,V> | |
Maps.NavigableKeySet<K,V> | |
Maps.SortedAsMapView<K,V> | |
Maps.SortedKeySet<K,V> | |
Maps.SortedMapDifferenceImpl<K,V> | |
Maps.TransformedEntriesMap<K,V1,V2> | |
Maps.TransformedEntriesNavigableMap<K,V1,V2> | |
Maps.TransformedEntriesSortedMap<K,V1,V2> | |
Maps.UnmodifiableBiMap<K,V> | |
Maps.UnmodifiableEntries<K,V> | |
Maps.UnmodifiableEntrySet<K,V> | |
Maps.UnmodifiableNavigableMap<K,V> | |
Maps.ValueDifferenceImpl<V> | |
Maps.Values<K,V> | |
Maps.ViewCachingAbstractMap<K,V> |
AbstractMap extension that makes it easy to cache customized keySet, values, and
entrySet views. |
MinMaxPriorityQueue<E> |
A double-ended priority queue, which provides constant-time access to both its least element and
its greatest element, as determined by the queue's specified comparator.
|
MinMaxPriorityQueue.Builder<B> |
The builder class used in creation of min-max priority queues.
|
MinMaxPriorityQueue.MoveDesc<E> | |
MoreCollectors |
Collectors not present in
java.util.stream.Collectors that are not otherwise associated
with a com.google.common type. |
MoreCollectors.ToOptionalState |
This atrocity is here to let us report several of the elements in the stream if there were more
than one, not just two.
|
MultimapBuilder<K0,V0> |
A builder for a multimap implementation that allows customization of the backing map and value
collection implementations used in a particular multimap.
|
MultimapBuilder.ArrayListSupplier<V> | |
MultimapBuilder.EnumSetSupplier<V extends java.lang.Enum<V>> | |
MultimapBuilder.HashSetSupplier<V> | |
MultimapBuilder.LinkedHashSetSupplier<V> | |
MultimapBuilder.ListMultimapBuilder<K0,V0> |
A specialization of
MultimapBuilder that generates ListMultimap instances. |
MultimapBuilder.MultimapBuilderWithKeys<K0> |
An intermediate stage in a
MultimapBuilder in which the key-value collection map
implementation has been specified, but the value collection implementation has not. |
MultimapBuilder.SetMultimapBuilder<K0,V0> |
A specialization of
MultimapBuilder that generates SetMultimap instances. |
MultimapBuilder.SortedSetMultimapBuilder<K0,V0> |
A specialization of
MultimapBuilder that generates SortedSetMultimap instances. |
MultimapBuilder.TreeSetSupplier<V> | |
Multimaps |
Provides static methods acting on or generating a
Multimap . |
Multimaps.AsMap<K,V> |
A skeleton implementation of
Multimap.asMap() . |
Multimaps.CustomListMultimap<K,V> | |
Multimaps.CustomMultimap<K,V> | |
Multimaps.CustomSetMultimap<K,V> | |
Multimaps.CustomSortedSetMultimap<K,V> | |
Multimaps.Entries<K,V> |
A skeleton implementation of
Multimap.entries() . |
Multimaps.Keys<K,V> | |
Multimaps.MapMultimap<K,V> | |
Multimaps.TransformedEntriesListMultimap<K,V1,V2> | |
Multimaps.TransformedEntriesMultimap<K,V1,V2> | |
Multimaps.UnmodifiableListMultimap<K,V> | |
Multimaps.UnmodifiableMultimap<K,V> | |
Multimaps.UnmodifiableSetMultimap<K,V> | |
Multimaps.UnmodifiableSortedSetMultimap<K,V> | |
Multisets |
Provides static utility methods for creating and working with
Multiset instances. |
Multisets.AbstractEntry<E> | |
Multisets.DecreasingCount | |
Multisets.ElementSet<E> | |
Multisets.EntrySet<E> | |
Multisets.FilteredMultiset<E> | |
Multisets.ImmutableEntry<E> | |
Multisets.MultisetIteratorImpl<E> | |
Multisets.UnmodifiableMultiset<E> | |
Multisets.ViewMultiset<E> |
An
AbstractMultiset with additional default implementations, some of them linear-time
implementations in terms of elementSet and entrySet . |
MutableClassToInstanceMap<B> |
A mutable class-to-instance map backed by an arbitrary user-provided map.
|
MutableClassToInstanceMap.SerializedForm<B> |
Serialized form of the map, to avoid serializing the constraint.
|
NaturalOrdering |
An ordering that uses the natural order of the values.
|
NullsFirstOrdering<T> |
An ordering that treats
null as less than all other values. |
NullsLastOrdering<T> |
An ordering that treats
null as greater than all other values. |
ObjectArrays |
Static utility methods pertaining to object arrays.
|
Ordering<T> |
A comparator, with additional methods to support common operations.
|
Ordering.ArbitraryOrdering | |
Ordering.ArbitraryOrderingHolder | |
Platform |
Methods factored out so that they can be emulated differently in GWT.
|
Queues |
Static utility methods pertaining to
Queue and Deque instances. |
Range<C extends java.lang.Comparable> |
A range (or "interval") defines the boundaries around a contiguous span of values of some
Comparable type; for example, "integers from 1 to 100 inclusive." Note that it is not
possible to iterate over these contained values. |
Range.LowerBoundFn | |
Range.RangeLexOrdering |
Needed to serialize sorted collections of Ranges.
|
Range.UpperBoundFn | |
RangeGwtSerializationDependencies<C extends java.lang.Comparable> |
A dummy superclass to support GWT serialization of the element type of a
Range . |
RegularContiguousSet<C extends java.lang.Comparable> |
An implementation of
ContiguousSet that contains one or more elements. |
RegularContiguousSet.SerializedForm<C extends java.lang.Comparable> | |
RegularImmutableAsList<E> |
An
ImmutableAsList implementation specialized for when the delegate collection is already
backed by an ImmutableList or array. |
RegularImmutableBiMap<K,V> |
Bimap with zero or more mappings.
|
RegularImmutableBiMap.InverseSerializedForm<K,V> | |
RegularImmutableList<E> |
Implementation of
ImmutableList backed by a simple array. |
RegularImmutableMap<K,V> |
Implementation of
ImmutableMap with two or more entries. |
RegularImmutableMap.KeySet<K,V> | |
RegularImmutableMap.KeySet.SerializedForm<K> | |
RegularImmutableMap.Values<K,V> | |
RegularImmutableMap.Values.SerializedForm<V> | |
RegularImmutableMultiset<E> |
Implementation of
ImmutableMultiset with zero or more elements. |
RegularImmutableMultiset.NonTerminalEntry<E> | |
RegularImmutableSet<E> |
Implementation of
ImmutableSet with two or more elements. |
RegularImmutableSortedMultiset<E> |
An immutable sorted multiset with one or more distinct elements.
|
RegularImmutableSortedSet<E> |
An immutable sorted set with one or more elements.
|
RegularImmutableTable<R,C,V> |
An implementation of
ImmutableTable holding an arbitrary number of cells. |
ReverseNaturalOrdering |
An ordering that uses the reverse of the natural order of the values.
|
ReverseOrdering<T> |
An ordering that uses the reverse of a given order.
|
Serialization |
Provides static methods for serializing collection classes.
|
Serialization.FieldSetter<T> | |
Sets |
Static utility methods pertaining to
Set instances. |
Sets.Accumulator<E extends java.lang.Enum<E>> | |
Sets.CartesianSet<E> | |
Sets.DescendingSet<E> | |
Sets.FilteredNavigableSet<E> | |
Sets.FilteredSet<E> | |
Sets.FilteredSortedSet<E> | |
Sets.ImprovedAbstractSet<E> |
AbstractSet substitute without the potentially-quadratic removeAll
implementation. |
Sets.PowerSet<E> | |
Sets.SetView<E> |
An unmodifiable view of a set which may be backed by other sets; this view will change as the
backing sets do.
|
Sets.SubSet<E> | |
Sets.UnmodifiableNavigableSet<E> | |
SingletonImmutableBiMap<K,V> |
Implementation of
ImmutableMap with exactly one entry. |
SingletonImmutableList<E> |
Implementation of
ImmutableList with exactly one element. |
SingletonImmutableSet<E> |
Implementation of
ImmutableSet with exactly one element. |
SingletonImmutableTable<R,C,V> |
An implementation of
ImmutableTable that holds a single cell. |
SortedIterables |
Utilities for dealing with sorted collections of all types.
|
SortedLists |
Static methods pertaining to sorted
List instances. |
SortedMultisets |
Provides static utility methods for creating and working with
SortedMultiset instances. |
SortedMultisets.ElementSet<E> |
A skeleton implementation for
SortedMultiset.elementSet() . |
SortedMultisets.NavigableElementSet<E> |
A skeleton navigable implementation for
SortedMultiset.elementSet() . |
SparseImmutableTable<R,C,V> |
A
RegularImmutableTable optimized for sparse data. |
StandardRowSortedTable<R,C,V> |
Implementation of
Table whose iteration ordering across row keys is sorted by their
natural ordering or by a supplied comparator. |
StandardTable<R,C,V> |
Table implementation backed by a map that associates row keys with column key / value
secondary maps. |
Streams |
Static utility methods related to
Stream instances. |
Streams.MapWithIndexSpliterator<F extends java.util.Spliterator<?>,R,S extends Streams.MapWithIndexSpliterator<F,R,S>> | |
Streams.TemporaryPair<A,B> | |
Synchronized |
Synchronized collection views.
|
Synchronized.SynchronizedAsMap<K,V> | |
Synchronized.SynchronizedAsMapEntries<K,V> | |
Synchronized.SynchronizedAsMapValues<V> | |
Synchronized.SynchronizedBiMap<K,V> | |
Synchronized.SynchronizedCollection<E> | |
Synchronized.SynchronizedDeque<E> | |
Synchronized.SynchronizedEntry<K,V> | |
Synchronized.SynchronizedList<E> | |
Synchronized.SynchronizedListMultimap<K,V> | |
Synchronized.SynchronizedMap<K,V> | |
Synchronized.SynchronizedMultimap<K,V> | |
Synchronized.SynchronizedMultiset<E> | |
Synchronized.SynchronizedNavigableMap<K,V> | |
Synchronized.SynchronizedNavigableSet<E> | |
Synchronized.SynchronizedObject | |
Synchronized.SynchronizedQueue<E> | |
Synchronized.SynchronizedRandomAccessList<E> | |
Synchronized.SynchronizedSet<E> | |
Synchronized.SynchronizedSetMultimap<K,V> | |
Synchronized.SynchronizedSortedMap<K,V> | |
Synchronized.SynchronizedSortedSet<E> | |
Synchronized.SynchronizedSortedSetMultimap<K,V> | |
Synchronized.SynchronizedTable<R,C,V> | |
Tables |
Provides static methods that involve a
Table . |
Tables.AbstractCell<R,C,V> | |
Tables.ImmutableCell<R,C,V> | |
Tables.TransformedTable<R,C,V1,V2> | |
Tables.TransposeTable<C,R,V> | |
Tables.UnmodifiableRowSortedMap<R,C,V> | |
Tables.UnmodifiableTable<R,C,V> | |
TopKSelector<T> |
An accumulator that selects the "top"
k elements added to it, relative to a provided
comparator. |
TransformedIterator<F,T> |
An iterator that transforms a backing iterator; for internal use.
|
TransformedListIterator<F,T> |
An iterator that transforms a backing list iterator; for internal use.
|
TreeBasedTable<R,C,V> |
Implementation of
Table whose row keys and column keys are ordered by their natural
ordering or by supplied comparators. |
TreeBasedTable.Factory<C,V> | |
TreeMultimap<K,V> |
Implementation of
Multimap whose keys and values are ordered by their natural ordering or
by supplied comparators. |
TreeMultiset<E> |
A multiset which maintains the ordering of its elements, according to either their natural order
or an explicit
Comparator . |
TreeMultiset.AvlNode<E> | |
TreeMultiset.Reference<T> | |
TreeRangeMap<K extends java.lang.Comparable,V> |
An implementation of
RangeMap based on a TreeMap , supporting all optional
operations. |
TreeRangeMap.RangeMapEntry<K extends java.lang.Comparable,V> | |
TreeRangeSet<C extends java.lang.Comparable<?>> |
An implementation of
RangeSet backed by a TreeMap . |
TreeRangeSet.ComplementRangesByLowerBound<C extends java.lang.Comparable<?>> | |
TreeRangeSet.RangesByUpperBound<C extends java.lang.Comparable<?>> | |
TreeRangeSet.SubRangeSetRangesByLowerBound<C extends java.lang.Comparable<?>> | |
TreeTraverser<T> | Deprecated
Use
Traverser instead. |
TreeTraverser.PostOrderNode<T> | |
UnmodifiableIterator<E> |
An iterator that does not support
UnmodifiableIterator.remove() . |
UnmodifiableListIterator<E> |
A list iterator that does not support
UnmodifiableIterator.remove() , UnmodifiableListIterator.add(E) , or UnmodifiableListIterator.set(E) . |
UnmodifiableSortedMultiset<E> |
Implementation of
Multisets.unmodifiableSortedMultiset(SortedMultiset) , split out into
its own file so it can be GWT emulated (to deal with the differing elementSet() types in GWT and
non-GWT). |
UsingToStringOrdering |
An ordering that uses the natural order of the string representation of the values.
|
WellBehavedMap<K,V> |
Workaround for EnumMap
bug.
|
Enum | Description |
---|---|
AbstractIterator.State | |
BoundType |
Indicates whether an endpoint of some range is contained in the range itself ("closed") or not
("open").
|
Iterators.EmptyModifiableIterator |
This is an enum singleton rather than an anonymous class so ProGuard can figure out it's only
referenced by emptyModifiableIterator().
|
MapMaker.Dummy |
A dummy singleton value type used by
Interners . |
MapMakerInternalMap.Strength | |
Maps.EntryFunction | |
MultimapBuilder.LinkedListSupplier | |
SortedLists.KeyAbsentBehavior |
A specification for which index to return if the list contains no elements that compare as
equal to the key.
|
SortedLists.KeyPresentBehavior |
A specification for which index to return if the list contains at least one element that
compares as equal to the key.
|
TreeMultiset.Aggregate |
A function which can be summed across a subtree.
|
Exception | Description |
---|---|
ComputationException |
Wraps an exception that occurred during a computation.
|
Ordering.IncomparableValueException |
Exception thrown by a
Ordering.explicit(List) or Ordering.explicit(Object,
Object[]) comparator when comparing a value outside the set of values it can compare. |
Annotation Type | Description |
---|---|
GwtTransient |
Private replacement for
com.google.gwt.user.client.rpc.GwtTransient to work around
build-system quirks. |
BiMap
Map
that guarantees the uniqueness of its values as well
as that of its keys. This is sometimes called an "invertible map," since the restriction on
values enables it to support an inverse
view -- which is another instance of BiMap
.
Multiset
Collection
that may contain duplicate values like a
List
, yet has order-independent equality like a Set
.
One typical use for a multiset is to represent a histogram.
Multimap
Map
, but may contain multiple entries
with the same key. Some behaviors of Multimap
are left
unspecified and are provided only by the subtypes mentioned below.
ListMultimap
Multimap
which permits duplicate entries,
supports random access of values for a particular key, and has partially order-dependent
equality as defined by ListMultimap.equals(Object)
.
ListMultimap
takes its name from the fact that the collection of values associated with a given
key fulfills the List
contract.
SetMultimap
Multimap
which has order-independent
equality and does not allow duplicate entries; that is, while a key may appear twice in a
SetMultimap
, each must map to a different value. SetMultimap
takes its name
from the fact that the collection of
values associated with a given key fulfills the Set
contract.
SortedSetMultimap
SetMultimap
for which the collection values associated with a given
key is a SortedSet
.
Table
Map
, but which indexes its values by an
ordered pair of keys, a row key and column key.
ClassToInstanceMap
Map
that associates a raw type with an instance of that
type.
List
Set
ImmutableSet
ImmutableSortedSet
ContiguousSet
(see Range
)
Map
BiMap
Multiset
Multimap
ImmutableMultimap
ImmutableListMultimap
ImmutableSetMultimap
ArrayListMultimap
HashMultimap
TreeMultimap
LinkedHashMultimap
LinkedListMultimap
Table
ClassToInstanceMap
AbstractIterator
AbstractSequentialIterator
ImmutableCollection
UnmodifiableIterator
UnmodifiableListIterator
ForwardingCollection
ForwardingConcurrentMap
ForwardingIterator
ForwardingList
ForwardingListIterator
ForwardingListMultimap
ForwardingMap
ForwardingMapEntry
ForwardingMultimap
ForwardingMultiset
ForwardingNavigableMap
ForwardingNavigableSet
ForwardingObject
ForwardingQueue
ForwardingSet
ForwardingSetMultimap
ForwardingSortedMap
ForwardingSortedMultiset
ForwardingSortedSet
ForwardingSortedSetMultimap
ForwardingTable