All Classes

Class	Description
AbstractCache<K,V>	This class provides a skeletal implementation of the Cache interface to minimize the effort required to implement this interface.
AbstractCache.SimpleStatsCounter	A thread-safe AbstractCache.StatsCounter implementation for use by Cache implementors.
AbstractCache.StatsCounter	Accumulates statistics during the operation of a Cache for presentation by Cache.stats().
AbstractExecutionThreadService	Base class for services that can implement AbstractExecutionThreadService.startUp(), AbstractExecutionThreadService.run() and AbstractExecutionThreadService.shutDown() methods.
AbstractFuture<V>	An abstract implementation of ListenableFuture, intended for advanced users only.
AbstractGraph<N>	This class provides a skeletal implementation of Graph.
AbstractIdleService	Base class for services that do not need a thread while "running" but may need one during startup and shutdown.
AbstractInvocationHandler	Abstract implementation of InvocationHandler that handles Object.equals(java.lang.Object), Object.hashCode() and Object.toString().
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.
AbstractListeningExecutorService	Abstract ListeningExecutorService implementation that creates ListenableFuture instances for each Runnable and Callable submitted to it.
AbstractLoadingCache<K,V>	This class provides a skeletal implementation of the Cache interface to minimize the effort required to implement this interface.
AbstractNetwork<N,E>	This class provides a skeletal implementation of Network.
AbstractScheduledService	Base class for services that can implement AbstractScheduledService.startUp() and AbstractScheduledService.shutDown() but while in the "running" state need to perform a periodic task.
AbstractScheduledService.CustomScheduler	A AbstractScheduledService.Scheduler that provides a convenient way for the AbstractScheduledService to use a dynamically changing schedule.
AbstractScheduledService.CustomScheduler.Schedule	A value object that represents an absolute delay until a task should be invoked.
AbstractScheduledService.Scheduler	A scheduler defines the policy for how the AbstractScheduledService should run its task.
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.
AbstractService	Base class for implementing services that can handle AbstractService.doStart() and AbstractService.doStop() requests, responding to them with AbstractService.notifyStarted() and AbstractService.notifyStopped() callbacks.
AbstractValueGraph<N,V>	This class provides a skeletal implementation of ValueGraph.
AllowConcurrentEvents	Marks an event subscriber method as being thread-safe.
ArrayBasedCharEscaper	A CharEscaper that uses an array to quickly look up replacement characters for a given char value.
ArrayBasedEscaperMap	An implementation-specific parameter class suitable for initializing ArrayBasedCharEscaper or ArrayBasedUnicodeEscaper instances.
ArrayBasedUnicodeEscaper	A UnicodeEscaper that uses an array to quickly look up replacement characters for a given code point.
ArrayListMultimap<K,V>	Implementation of Multimap that uses an ArrayList to store the values for a given key.
ArrayTable<R,C,V>	Fixed-size Table implementation backed by a two-dimensional array.
Ascii	Static methods pertaining to ASCII characters (those in the range of values 0x00 through 0x7F), and to strings containing such characters.
AsyncCallable<V>	Computes a value, possibly asynchronously.
AsyncEventBus	An EventBus that takes the Executor of your choice and uses it to dispatch events, allowing dispatch to occur asynchronously.
AsyncFunction<I,O>	Transforms a value, possibly asynchronously.
AtomicDouble	A double value that may be updated atomically.
AtomicDoubleArray	A double array in which elements may be updated atomically.
AtomicLongMap<K>	A map containing long values that can be atomically updated.
Atomics	Static utility methods pertaining to classes in the java.util.concurrent.atomic package.
BaseEncoding	A binary encoding scheme for reversibly translating between byte sequences and printable ASCII strings.
BaseEncoding.DecodingException	Exception indicating invalid base-encoded input encountered while decoding.
Beta	Signifies that a public API (public class, method or field) is subject to incompatible changes, or even removal, in a future release.
BigIntegerMath	A class for arithmetic on values of type BigInteger.
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.
BloomFilter<T>	A Bloom filter for instances of T.
Booleans	Static utility methods pertaining to boolean primitives, that are not already found in either Boolean or Arrays.
BoundType	Indicates whether an endpoint of some range is contained in the range itself ("closed") or not ("open").
ByteArrayDataInput	An extension of DataInput for reading from in-memory byte arrays; its methods offer identical functionality but do not throw IOException.
ByteArrayDataOutput	An extension of DataOutput for writing to in-memory byte arrays; its methods offer identical functionality but do not throw IOException.
ByteProcessor<T>	A callback interface to process bytes from a stream.
Bytes	Static utility methods pertaining to byte primitives, that are not already found in either Byte or Arrays, and interpret bytes as neither signed nor unsigned.
ByteSink	A destination to which bytes can be written, such as a file.
ByteSource	A readable source of bytes, such as a file.
ByteStreams	Provides utility methods for working with byte arrays and I/O streams.
Cache<K,V>	A semi-persistent mapping from keys to values.
CacheBuilder<K,V>	A builder of LoadingCache and Cache instances having any combination of the following features: automatic loading of entries into the cache least-recently-used eviction when a maximum size is exceeded time-based expiration of entries, measured since last access or last write keys automatically wrapped in WeakReference values automatically wrapped in WeakReference or SoftReference notification of evicted (or otherwise removed) entries accumulation of cache access statistics
CacheBuilderSpec	A specification of a CacheBuilder configuration.
CacheLoader<K,V>	Computes or retrieves values, based on a key, for use in populating a LoadingCache.
CacheLoader.InvalidCacheLoadException	Thrown to indicate that an invalid response was returned from a call to CacheLoader.
CacheLoader.UnsupportedLoadingOperationException	Exception thrown by loadAll() to indicate that it is not supported.
CacheStats	Statistics about the performance of a Cache.
Callables	Static utility methods pertaining to the Callable interface.
CanIgnoreReturnValue	Indicates that the return value of the annotated method can be safely ignored.
CaseFormat	Utility class for converting between various ASCII case formats.
CharEscaper	An object that converts literal text into a format safe for inclusion in a particular context (such as an XML document).
CharEscaperBuilder	Simple helper class to build a "sparse" array of objects based on the indexes that were added to it.
CharMatcher	Determines a true or false value for any Java char value, just as Predicate does for any Object.
Chars	Static utility methods pertaining to char primitives, that are not already found in either Character or Arrays.
Charsets	Contains constant definitions for the six standard Charset instances, which are guaranteed to be supported by all Java platform implementations.
CharSink	A destination to which characters can be written, such as a text file.
CharSource	A readable source of characters, such as a text file.
CharStreams	Provides utility methods for working with character streams.
CheckReturnValue	Indicates that the return value of the annotated method must be checked.
ClassPath	Scans the source of a ClassLoader and finds all loadable classes and resources.
ClassPath.ClassInfo	Represents a class that can be loaded through ClassPath.ClassInfo.load().
ClassPath.ResourceInfo	Represents a class path resource that can be either a class file or any other resource file loadable from the class path.
ClassToInstanceMap<B>	A map, each entry of which maps a Java raw type to an instance of that type.
Closeables	Utility methods for working with Closeable objects.
Closer	A Closeable that collects Closeable resources and closes them all when it is closed.
Collections2	Provides static methods for working with Collection instances.
Comparators	Provides static methods for working with Comparator instances.
ComparisonChain	A utility for performing a chained comparison statement.
CompatibleWith	Declares that a parameter to a method must be "compatible with" one of the type parameters in the method's enclosing class, or on the method itself.
ComputationException	Deprecated. This exception is no longer thrown by com.google.common.
ConcurrentHashMultiset<E>	A multiset that supports concurrent modifications and that provides atomic versions of most Multiset operations (exceptions where noted).
ContiguousSet<C extends java.lang.Comparable>	A sorted set of contiguous values in a given DiscreteDomain.
Converter<A,B>	A function from A to B with an associated reverse function from B to A; used for converting back and forth between different representations of the same information.
CountingInputStream	An InputStream that counts the number of bytes read.
CountingOutputStream	An OutputStream that counts the number of bytes written.
CycleDetectingLockFactory	The CycleDetectingLockFactory creates ReentrantLock instances and ReentrantReadWriteLock instances that detect potential deadlock by checking for cycles in lock acquisition order.
CycleDetectingLockFactory.Policies	Pre-defined CycleDetectingLockFactory.Policy implementations.
CycleDetectingLockFactory.Policy	Encapsulates the action to be taken when a potential deadlock is encountered.
CycleDetectingLockFactory.PotentialDeadlockException	Represents a detected cycle in lock acquisition ordering.
CycleDetectingLockFactory.WithExplicitOrdering<E extends java.lang.Enum<E>>	A CycleDetectingLockFactory.WithExplicitOrdering provides the additional enforcement of an application-specified ordering of lock acquisitions.
DeadEvent	Wraps an event that was posted, but which had no subscribers and thus could not be delivered.
Defaults	This class provides default values for all Java types, as defined by the JLS.
DiscreteDomain<C extends java.lang.Comparable>	A descriptor for a discrete Comparable domain such as all Integer instances.
DoNotCall	The method to which this annotation is applied cannot be called.
DoNotMock	Annotation representing a type that should not be mocked.
DoubleMath	A class for arithmetic on doubles that is not covered by Math.
Doubles	Static utility methods pertaining to double primitives, that are not already found in either Double or Arrays.
ElementOrder<T>	Used to represent the order of elements in a data structure that supports different options for iteration order guarantees.
ElementOrder.Type	The type of ordering that this object specifies.
EndpointPair<N>	An immutable pair representing the two endpoints of an edge in a graph.
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).
Enums	Utility methods for working with Enum instances.
Equivalence<T>	A strategy for determining whether two instances are considered equivalent, and for computing hash codes in a manner consistent with that equivalence.
Equivalence.Wrapper<T>	Wraps an object so that Equivalence.Wrapper.equals(Object) and Equivalence.Wrapper.hashCode() delegate to an Equivalence.
Escaper	An object that converts literal text into a format safe for inclusion in a particular context (such as an XML document).
Escapers	Static utility methods pertaining to Escaper instances.
Escapers.Builder	A builder for simple, fast escapers.
EventBus	Dispatches events to listeners, and provides ways for listeners to register themselves.
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.
ExecutionError	Error variant of ExecutionException.
ExecutionList	A support class for ListenableFuture implementations to manage their listeners.
ExecutionSequencer	Serializes execution of a set of operations.
FakeTimeLimiter	A TimeLimiter implementation which actually does not attempt to limit time at all.
FileBackedOutputStream	An OutputStream that starts buffering to a byte array, but switches to file buffering once the data reaches a configurable size.
Files	Provides utility methods for working with files.
FileWriteMode	Modes for opening a file for writing.
FinalizablePhantomReference<T>	Phantom reference with a finalizeReferent() method which a background thread invokes after the garbage collector reclaims the referent.
FinalizableReference	Implemented by references that have code to run after garbage collection of their referents.
FinalizableReferenceQueue	A reference queue with an associated background thread that dequeues references and invokes FinalizableReference.finalizeReferent() on them.
FinalizableSoftReference<T>	Soft reference with a finalizeReferent() method which a background thread invokes after the garbage collector reclaims the referent.
FinalizableWeakReference<T>	Weak reference with a finalizeReferent() method which a background thread invokes after the garbage collector reclaims the referent.
Floats	Static utility methods pertaining to float primitives, that are not already found in either Float or Arrays.
FluentFuture<V>	A ListenableFuture that supports fluent chains of operations.
FluentIterable<E>	A discouraged (but not deprecated) precursor to Java's superior Stream library.
Flushables	Utility methods for working with Flushable objects.
ForOverride	Indicates that the annotated method is provided only to be overridden: it should not be invoked from outside its declaring source file (as if it is private), and overriding methods should not be directly invoked at all.
ForwardingBlockingDeque<E>	Deprecated. This class has moved to com.google.common.util.concurrent.
ForwardingBlockingDeque<E>	A BlockingDeque which forwards all its method calls to another BlockingDeque.
ForwardingBlockingQueue<E>	A BlockingQueue which forwards all its method calls to another BlockingQueue.
ForwardingCache<K,V>	A cache which forwards all its method calls to another cache.
ForwardingCache.SimpleForwardingCache<K,V>	A simplified version of ForwardingCache where subclasses can pass in an already constructed Cache as the delegate.
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.
ForwardingExecutorService	An executor service which forwards all its method calls to another executor service.
ForwardingFuture<V>	A Future which forwards all its method calls to another future.
ForwardingFuture.SimpleForwardingFuture<V>	A simplified version of ForwardingFuture where subclasses can pass in an already constructed Future as the delegate.
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.
ForwardingListenableFuture<V>	A ListenableFuture which forwards all its method calls to another future.
ForwardingListenableFuture.SimpleForwardingListenableFuture<V>	A simplified version of ForwardingListenableFuture where subclasses can pass in an already constructed ListenableFuture as the delegate.
ForwardingListeningExecutorService	A listening executor service which forwards all its method calls to another listening executor service.
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.
ForwardingLoadingCache<K,V>	A cache which forwards all its method calls to another cache.
ForwardingLoadingCache.SimpleForwardingLoadingCache<K,V>	A simplified version of ForwardingLoadingCache where subclasses can pass in an already constructed LoadingCache as the delegate.
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.
Function<F,T>	Legacy version of java.util.function.Function.
Functions	Static utility methods pertaining to com.google.common.base.Function instances; see that class for information about migrating to java.util.function.
Funnel<T>	An object which can send data from an object of type T into a PrimitiveSink.
Funnels	Funnels for common types.
FutureCallback<V>	A callback for accepting the results of a Future computation asynchronously.
Futures	Static utility methods pertaining to the Future interface.
Futures.FutureCombiner<V>	A helper to create a new ListenableFuture whose result is generated from a combination of input futures.
Graph<N>	An interface for graph-structured data, whose edges are anonymous entities with no identity or information of their own.
GraphBuilder<N>	A builder for constructing instances of MutableGraph or ImmutableGraph with user-defined properties.
Graphs	Static utility methods for Graph, ValueGraph, and Network instances.
GuardedBy	Indicates that the annotated element should be used only while holding the specified lock.
GwtCompatible	The presence of this annotation on a type indicates that the type may be used with the Google Web Toolkit (GWT).
GwtIncompatible	The presence of this annotation on an API indicates that the method may not be used with the Google Web Toolkit (GWT).
HashBasedTable<R,C,V>	Implementation of Table using linked hash tables.
HashBiMap<K,V>	A BiMap backed by two hash tables.
HashCode	An immutable hash code of arbitrary bit length.
Hasher	A PrimitiveSink that can compute a hash code after reading the input.
HashFunction	A hash function is a collision-averse pure function that maps an arbitrary block of data to a number called a hash code.
Hashing	Static methods to obtain HashFunction instances, and other static hashing-related utilities.
HashingInputStream	An InputStream that maintains a hash of the data read from it.
HashingOutputStream	An OutputStream that maintains a hash of the data written to it.
HashMultimap<K,V>	Implementation of Multimap using hash tables.
HashMultiset<E>	Multiset implementation backed by a HashMap.
HostAndPort	An immutable representation of a host and port.
HostSpecifier	A syntactically valid host specifier, suitable for use in a URI.
HtmlEscapers	Escaper instances suitable for strings to be included in HTML attribute values and most elements' text contents.
HttpHeaders	Contains constant definitions for the HTTP header field names.
HttpHeaders.ReferrerPolicyValues	Values for the Referrer-Policy header.
Immutable	The class to which this annotation is applied is immutable.
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").
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.
ImmutableDoubleArray	An immutable array of double values, with an API resembling List.
ImmutableDoubleArray.Builder	A builder for ImmutableDoubleArray instances; obtained using ImmutableDoubleArray.builder(int).
ImmutableGraph<N>	A Graph whose elements and structural relationships will never change.
ImmutableGraph.Builder<N>	A builder for creating ImmutableGraph instances, especially static final graphs.
ImmutableIntArray	An immutable array of int values, with an API resembling List.
ImmutableIntArray.Builder	A builder for ImmutableIntArray instances; obtained using ImmutableIntArray.builder(int).
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").
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").
ImmutableLongArray	An immutable array of long values, with an API resembling List.
ImmutableLongArray.Builder	A builder for ImmutableLongArray instances; obtained using ImmutableLongArray.builder(int).
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").
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").
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").
ImmutableNetwork<N,E>	A Network whose elements and structural relationships will never change.
ImmutableNetwork.Builder<N,E>	A builder for creating ImmutableNetwork instances, especially static final networks.
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.
ImmutableRangeSet<C extends java.lang.Comparable>	A RangeSet whose contents will never change, with many other important properties detailed at ImmutableCollection.
ImmutableRangeSet.Builder<C extends java.lang.Comparable<?>>	A builder for immutable range sets.
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.
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").
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").
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").
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.
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").
ImmutableTypeToInstanceMap<B>	A type-to-instance map backed by an ImmutableMap.
ImmutableTypeToInstanceMap.Builder<B>	A builder for creating immutable type-to-instance maps.
ImmutableValueGraph<N,V>	A ValueGraph whose elements and structural relationships will never change.
ImmutableValueGraph.Builder<N,V>	A builder for creating ImmutableValueGraph instances, especially static final graphs.
InetAddresses	Static utility methods pertaining to InetAddress instances.
InetAddresses.TeredoInfo	A simple immutable data class to encapsulate the information to be found in a Teredo address.
InputSupplier<T>	Deprecated. For InputSupplier<? extends InputStream>, use ByteSource instead.
InsecureRecursiveDeleteException	Exception indicating that a recursive delete can't be performed because the file system does not have the support necessary to guarantee that it is not vulnerable to race conditions that would allow it to delete files and directories outside of the directory being deleted (i.e., SecureDirectoryStream is not supported).
InternalFutureFailureAccess	A future that, if it fails, may optionally provide access to the cause of the failure.
InternalFutures	Static utilities for InternalFutureFailureAccess.
Interner<E>	Provides equivalent behavior to String.intern() for other immutable types.
Interners	Contains static methods pertaining to instances of Interner.
Interners.InternerBuilder	Builder for Interner instances.
InternetDomainName	An immutable well-formed internet domain name, such as com or foo.co.uk.
IntMath	A class for arithmetic on values of type int.
Ints	Static utility methods pertaining to int primitives, that are not already found in either Integer or Arrays.
Invokable<T,R>	Wrapper around either a Method or a Constructor.
Iterables	An assortment of mainly legacy static utility methods that operate on or return objects of type Iterable.
Iterators	This class contains static utility methods that operate on or return objects of type Iterator.
J2ObjCIncompatible	Marks a declaration to be stripped by the J2ObjC translator prior to compilation.
JdkFutureAdapters	Utilities necessary for working with libraries that supply plain Future instances.
Joiner	An object which joins pieces of text (specified as an array, Iterable, varargs or even a Map) with a separator.
Joiner.MapJoiner	An object that joins map entries in the same manner as Joiner joins iterables and arrays.
LazyInit	Use this annotation on any static or field that will be initialized lazily, where races yield no semantic difference in the code (as, for example, is the case with String.hashCode()).
LinearTransformation	The representation of a linear transformation between real numbers x and y.
LinearTransformation.LinearTransformationBuilder	This is an intermediate stage in the construction process.
LineProcessor<T>	A callback to be used with the streaming readLines methods.
LineReader	A class for reading lines of text.
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.
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.
ListenableFuture<V>	A Future that accepts completion listeners.
ListenableFutureTask<V>	A FutureTask that also implements the ListenableFuture interface.
ListenableScheduledFuture<V>	Helper interface to implement both ListenableFuture and ScheduledFuture.
ListeningExecutorService	An ExecutorService that returns ListenableFuture instances.
ListeningScheduledExecutorService	A ScheduledExecutorService that returns ListenableFuture instances from its ExecutorService methods.
ListMultimap<K,V>	A Multimap that can hold duplicate key-value pairs and that maintains the insertion ordering of values for a given key.
Lists	Static utility methods pertaining to List instances.
LittleEndianDataInputStream	An implementation of DataInput that uses little-endian byte ordering for reading short, int, float, double, and long values.
LittleEndianDataOutputStream	An implementation of DataOutput that uses little-endian byte ordering for writing char, short, int, float, double, and long values.
LoadingCache<K,V>	A semi-persistent mapping from keys to values.
LongMath	A class for arithmetic on values of type long.
Longs	Static utility methods pertaining to long primitives, that are not already found in either Long or Arrays.
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.
MapMaker	A builder of ConcurrentMap instances that can have keys or values automatically wrapped in weak references.
Maps	Static utility methods pertaining to Map instances (including instances of SortedMap, BiMap, etc.).
Maps.EntryTransformer<K,V1,V2>	A transformation of the value of a key-value pair, using both key and value as inputs.
MediaType	Represents an Internet Media Type (also known as a MIME Type or Content Type).
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.
Monitor	A synchronization abstraction supporting waiting on arbitrary boolean conditions.
Monitor.Guard	A boolean condition for which a thread may wait.
MoreCollectors	Collectors not present in java.util.stream.Collectors that are not otherwise associated with a com.google.common type.
MoreExecutors	Factory and utility methods for Executor, ExecutorService, and ThreadFactory.
MoreFiles	Static utilities for use with Path instances, intended to complement Files.
MoreObjects	Helper functions that operate on any Object, and are not already provided in Objects.
MoreObjects.ToStringHelper	Support class for MoreObjects.toStringHelper(java.lang.Object).
Multimap<K,V>	A collection that maps keys to values, similar to Map, but in which each key may be associated with multiple values.
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.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.
Multimaps	Provides static methods acting on or generating a Multimap.
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.
Multisets	Provides static utility methods for creating and working with Multiset instances.
MustBeClosed	Annotation for constructors of AutoCloseables or methods that return an AutoCloseable and require that the resource is closed.
MutableClassToInstanceMap<B>	A mutable class-to-instance map backed by an arbitrary user-provided map.
MutableGraph<N>	A subinterface of Graph which adds mutation methods.
MutableNetwork<N,E>	A subinterface of Network which adds mutation methods.
MutableTypeToInstanceMap<B>	A mutable type-to-instance map.
MutableValueGraph<N,V>	A subinterface of ValueGraph which adds mutation methods.
Network<N,E>	An interface for graph-structured data, whose edges are unique objects.
NetworkBuilder<N,E>	A builder for constructing instances of MutableNetwork or ImmutableNetwork with user-defined properties.
ObjectArrays	Static utility methods pertaining to object arrays.
Objects	Helper functions that can operate on any Object.
Objects.ToStringHelper	Deprecated. Use MoreObjects.ToStringHelper instead.
Optional<T>	An immutable object that may contain a non-null reference to another object.
Ordering<T>	A comparator, with additional methods to support common operations.
OutputSupplier<T>	Deprecated. For OutputSupplier<? extends OutputStream>, use ByteSink instead.
OverridingMethodsMustInvokeSuper	Indicates that any concrete method that overrides the annotated method, directly or indirectly, must invoke super.theAnnotatedMethod(...) at some point.
PairedStats	An immutable value object capturing some basic statistics about a collection of paired double values (e.g.
PairedStatsAccumulator	A mutable object which accumulates paired double values (e.g.
Parameter	Represents a method or constructor parameter.
PatternFilenameFilter	File name filter that only accepts files matching a regular expression.
PeekingIterator<E>	An iterator that supports a one-element lookahead while iterating.
PercentEscaper	A UnicodeEscaper that escapes some set of Java characters using a UTF-8 based percent encoding scheme.
Preconditions	Static convenience methods that help a method or constructor check whether it was invoked correctly (that is, whether its preconditions were met).
PredecessorsFunction<N>	A functional interface for graph-structured data.
Predicate<T>	Legacy version of java.util.function.Predicate.
Predicates	Static utility methods pertaining to Predicate instances.
Primitives	Contains static utility methods pertaining to primitive types and their corresponding wrapper types.
PrimitiveSink	An object which can receive a stream of primitive values.
Quantiles	Provides a fluent API for calculating quantiles.
Quantiles.Scale	Describes the point in a fluent API chain where only the scale (i.e.
Quantiles.ScaleAndIndex	Describes the point in a fluent API chain where the scale and a single quantile index (i.e.
Quantiles.ScaleAndIndexes	Describes the point in a fluent API chain where the scale and a multiple quantile indexes (i.e.
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.
RangeMap<K extends java.lang.Comparable,V>	A mapping from disjoint nonempty ranges to non-null values.
Ranges	Deprecated. Use the corresponding method in Range.
RangeSet<C extends java.lang.Comparable>	A set comprising zero or more nonempty, disconnected ranges of type C.
RateLimiter	A rate limiter.
RecursiveDeleteOption	Options for use with recursive delete methods (MoreFiles.deleteRecursively(java.nio.file.Path, com.google.common.io.RecursiveDeleteOption...) and MoreFiles.deleteDirectoryContents(java.nio.file.Path, com.google.common.io.RecursiveDeleteOption...)).
Reflection	Static utilities relating to Java reflection.
ReflectionSupport	Annotation that specifies the level of reflection support for a particular class.
ReflectionSupport.Level	Enumerates the available levels of reflection support.
RemovalCause	The reason why a cached entry was removed.
RemovalListener<K,V>	An object that can receive a notification when an entry is removed from a cache.
RemovalListeners	A collection of common removal listeners.
RemovalNotification<K,V>	A notification of the removal of a single entry.
Resources	Provides utility methods for working with resources in the classpath.
RetainedWith	PLEASE READ THIS DOCUMENTATION BEFORE USING THIS ANNOTATION!
RowSortedTable<R,C,V>	Interface that extends Table and whose rows are sorted.
Runnables	Static utility methods pertaining to the Runnable interface.
Service	An object with an operational state, plus asynchronous Service.startAsync() and Service.stopAsync() lifecycle methods to transition between states.
Service.Listener	A listener for the various state changes that a Service goes through in its lifecycle.
Service.State	The lifecycle states of a service.
ServiceManager	A manager for monitoring and controlling a set of services.
ServiceManager.Listener	A listener for the aggregate state changes of the services that are under management.
SetMultimap<K,V>	A Multimap that cannot hold duplicate key-value pairs.
Sets	Static utility methods pertaining to Set instances.
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.
SettableFuture<V>	A ListenableFuture whose result can be set by a SettableFuture.set(Object), SettableFuture.setException(Throwable) or SettableFuture.setFuture(ListenableFuture) call.
Shorts	Static utility methods pertaining to short primitives, that are not already found in either Short or Arrays.
SignedBytes	Static utility methods pertaining to byte primitives that interpret values as signed.
SimpleTimeLimiter	A TimeLimiter that runs method calls in the background using an ExecutorService.
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.
SortedSetMultimap<K,V>	A SetMultimap whose set of values for a given key are kept sorted; that is, they comprise a SortedSet.
Splitter	Extracts non-overlapping substrings from an input string, typically by recognizing appearances of a separator sequence.
Splitter.MapSplitter	An object that splits strings into maps as Splitter splits iterables and lists.
StandardSystemProperty	Represents a standard system property.
Stats	A bundle of statistical summary values -- sum, count, mean/average, min and max, and several forms of variance -- that were computed from a single set of zero or more floating-point values.
StatsAccumulator	A mutable object which accumulates double values and tracks some basic statistics over all the values added so far.
Stopwatch	An object that accurately measures elapsed time: the measured duration between two successive readings of "now" in the same process.
Streams	Static utility methods related to Stream instances.
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.
Strings	Static utility methods pertaining to String or CharSequence instances.
Striped<L>	A striped Lock/Semaphore/ReadWriteLock.
Subscribe	Marks a method as an event subscriber.
SubscriberExceptionContext	Context for an exception thrown by a subscriber.
SubscriberExceptionHandler	Handler for exceptions thrown by event subscribers.
SuccessorsFunction<N>	A functional interface for graph-structured data.
Supplier<T>	Legacy version of java.util.function.Supplier.
Suppliers	Useful suppliers.
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.
Tables	Provides static methods that involve a Table.
ThreadFactoryBuilder	A ThreadFactory builder, providing any combination of these features: whether threads should be marked as daemon threads a naming format a thread priority an uncaught exception handler a backing thread factory
Throwables	Static utility methods pertaining to instances of Throwable.
Ticker	A time source; returns a time value representing the number of nanoseconds elapsed since some fixed but arbitrary point in time.
TimeLimiter	Imposes a time limit on method calls.
Traverser<N>	An object that can traverse the nodes that are reachable from a specified (set of) start node(s) using a specified SuccessorsFunction.
TreeBasedTable<R,C,V>	Implementation of Table whose row keys and column keys are ordered by their natural ordering or by supplied comparators.
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.
TreeRangeMap<K extends java.lang.Comparable,V>	An implementation of RangeMap based on a TreeMap, supporting all optional operations.
TreeRangeSet<C extends java.lang.Comparable<?>>	An implementation of RangeSet backed by a TreeMap.
TreeTraverser<T>	Deprecated. Use Traverser instead.
TypeParameter<T>	Captures a free type variable that can be used in TypeToken.where(com.google.common.reflect.TypeParameter<X>, com.google.common.reflect.TypeToken<X>).
TypeResolver	An object of this class encapsulates type mappings from type variables.
TypeToInstanceMap<B>	A map, each entry of which maps a TypeToken to an instance of that type.
TypeToken<T>	A Type with generics.
UncaughtExceptionHandlers	Factories for Thread.UncaughtExceptionHandler instances.
UncheckedExecutionException	Unchecked variant of ExecutionException.
UncheckedTimeoutException	Unchecked version of TimeoutException.
UnicodeEscaper	An Escaper that converts literal text into a format safe for inclusion in a particular context (such as an XML document).
Uninterruptibles	Utilities for treating interruptible operations as uninterruptible.
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).
UnsignedBytes	Static utility methods pertaining to byte primitives that interpret values as unsigned (that is, any negative value b is treated as the positive value 256 + b).
UnsignedInteger	A wrapper class for unsigned int values, supporting arithmetic operations.
UnsignedInts	Static utility methods pertaining to int primitives that interpret values as unsigned (that is, any negative value x is treated as the positive value 2^32 + x).
UnsignedLong	A wrapper class for unsigned long values, supporting arithmetic operations.
UnsignedLongs	Static utility methods pertaining to long primitives that interpret values as unsigned (that is, any negative value x is treated as the positive value 2^64 + x).
UrlEscapers	Escaper instances suitable for strings to be included in particular sections of URLs.
Utf8	Low-level, high-performance utility methods related to the UTF-8 character encoding.
ValueGraph<N,V>	An interface for graph-structured data, whose edges have associated non-unique values.
ValueGraphBuilder<N,V>	A builder for constructing instances of MutableValueGraph or ImmutableValueGraph with user-defined properties.
Verify	Static convenience methods that serve the same purpose as Java language assertions, except that they are always enabled.
VerifyException	Exception thrown upon the failure of a verification check, including those performed by the convenience methods of the Verify class.
VisibleForTesting	Annotates a program element that exists, or is more widely visible than otherwise necessary, only for use in test code.
Weak	Annotation that indicates a variable has a weak relationship to its owner.
WeakOuter	Annotation that indicates an inner class has a weak relationship to its owning class.
Weigher<K,V>	Calculates the weights of cache entries.
XmlEscapers	Escaper instances suitable for strings to be included in XML attribute values and elements' text contents.