All Classes

Class	Description
Absent<T>	Implementation of an Optional not containing a reference.
AbstractBaseGraph<N>	This class provides a skeletal implementation of BaseGraph.
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.
AbstractBiMapTester<K,V>	Skeleton for a tester of a BiMap.
AbstractByteHasher	Abstract Hasher that handles converting primitives to bytes using a scratch ByteBuffer and streams all bytes to a sink to compute the hash.
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().
AbstractCatchingFuture<V,X extends java.lang.Throwable,F,T>	Implementations of Futures.catching*.
AbstractCatchingFuture.AsyncCatchingFuture<V,X extends java.lang.Throwable>	An AbstractCatchingFuture that delegates to an AsyncFunction and AbstractFuture.setFuture(ListenableFuture).
AbstractCatchingFuture.CatchingFuture<V,X extends java.lang.Throwable>	An AbstractCatchingFuture that delegates to a Function and AbstractFuture.set(Object).
AbstractCollectionTester<E>	Base class for collection testers.
AbstractCollectionTestSuiteBuilder<B extends AbstractCollectionTestSuiteBuilder<B,E>,E>	Abstract superclass of all test-suite builders for collection interfaces.
AbstractCompositeHashFunction	An abstract composition of multiple hash functions.
AbstractContainerTester<C,E>	Base class for testers of classes (including Collection and Map) that contain elements.
AbstractContainerTester.ArrayWithDuplicate<E>
AbstractDirectedNetworkConnections<N,E>	A base implementation of NetworkConnections for directed networks.
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.
AbstractFuture.AtomicHelper
AbstractFuture.Cancellation	A special value to represent cancellation and the 'wasInterrupted' bit.
AbstractFuture.Failure	A special value to represent failure, when AbstractFuture.setException(java.lang.Throwable) is called successfully.
AbstractFuture.Listener	Listeners also form a stack through the AbstractFuture.listeners field.
AbstractFuture.SafeAtomicHelper	AbstractFuture.AtomicHelper based on AtomicReferenceFieldUpdater.
AbstractFuture.SetFuture<V>	A special value that encodes the 'setFuture' state.
AbstractFuture.SynchronizedHelper	AbstractFuture.AtomicHelper based on synchronized and volatile writes.
AbstractFuture.Trusted<V>	Tag interface marking trusted subclasses.
AbstractFuture.TrustedFuture<V>	A less abstract subclass of AbstractFuture.
AbstractFuture.UnsafeAtomicHelper	AbstractFuture.AtomicHelper based on Unsafe.
AbstractFuture.Waiter	Waiter links form a Treiber stack, in the AbstractFuture.waiters field.
AbstractGraph<N>	This class provides a skeletal implementation of Graph.
AbstractGraphBuilder<N>	A base class for builders that construct graphs with user-defined properties.
AbstractHasher	An abstract implementation of Hasher, which only requires subtypes to implement Hasher.putByte(byte).
AbstractHashFunction	Skeleton implementation of HashFunction in terms of HashFunction.newHasher().
AbstractIdleService	Base class for services that do not need a thread while "running" but may need one during startup and shutdown.
AbstractIndexedListIterator<E>	This class provides a skeletal implementation of the ListIterator interface across a fixed number of elements that may be retrieved by position.
AbstractInvocationHandler	Abstract implementation of InvocationHandler that handles Object.equals(java.lang.Object), Object.hashCode() and Object.toString().
AbstractIterator<T>	Note this class is a copy of AbstractIterator (for dependency reasons).
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.
AbstractIterator.State
AbstractIterator.State
AbstractIteratorTester<E,I extends java.util.Iterator<E>>	Most of the logic for IteratorTester and ListIteratorTester.
AbstractIteratorTester.IteratorOperation
AbstractIteratorTester.KnownOrder
AbstractIteratorTester.PermittedMetaException	Meta-exception thrown by AbstractIteratorTester.MultiExceptionListIterator instead of throwing any particular exception type.
AbstractIteratorTester.Stimulus<E,T extends java.util.Iterator<E>>
AbstractIteratorTester.UnknownElementException
AbstractListenableFutureTest	Abstract test case parent for anything implementing ListenableFuture.
AbstractListeningExecutorService	Abstract ListeningExecutorService implementation that creates ListenableFuture instances for each Runnable and Callable submitted to it.
AbstractListIndexOfTester<E>	Common parent class for ListIndexOfTester and ListLastIndexOfTester.
AbstractListMultimap<K,V>	Basic implementation of the ListMultimap interface.
AbstractListMultimapTester<K,V>	Superclass for all ListMultimap testers.
AbstractListTester<E>	Base class for list testers.
AbstractLoadingCache<K,V>	This class provides a skeletal implementation of the Cache interface to minimize the effort required to implement this 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.
AbstractMapTester<K,V>	Base class for map testers.
AbstractMultimap<K,V>	A skeleton Multimap implementation, not necessarily in terms of a Map.
AbstractMultimapTester<K,V,M extends Multimap<K,V>>	Superclass for all Multimap testers.
AbstractMultiset<E>	This class provides a skeletal implementation of the Multiset interface.
AbstractMultisetSetCountTester<E>	Common superclass for MultisetSetCountUnconditionallyTester and MultisetSetCountConditionallyTester.
AbstractMultisetTester<E>	Base class for multiset collection tests.
AbstractNavigableMap<K,V>	Skeletal implementation of NavigableMap.
AbstractNetwork<N,E>	This class provides a skeletal implementation of Network.
AbstractNonStreamingHashFunction	Skeleton implementation of HashFunction, appropriate for non-streaming algorithms.
AbstractNonStreamingHashFunction.ExposedByteArrayOutputStream
AbstractPackageSanityTests	Automatically runs sanity checks against top level classes in the same package of the test that extends AbstractPackageSanityTests.
AbstractPackageSanityTests.Chopper
AbstractQueueTester<E>	Base class for queue collection tests.
AbstractRangeSet<C extends java.lang.Comparable>	A skeletal implementation of RangeSet.
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.
AbstractService.StateSnapshot	An immutable snapshot of the current state of the service.
AbstractSetMultimap<K,V>	Basic implementation of the SetMultimap interface.
AbstractSetTester<E>
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.
AbstractStreamingHasher	A convenience base class for implementors of Hasher; handles accumulating data until an entire "chunk" (of implementation-dependent length) is ready to be hashed.
AbstractTable<R,C,V>	Skeletal, implementation-agnostic implementation of the Table interface.
AbstractTester<G>	This abstract base class for testers allows the framework to inject needed information after JUnit constructs the instances.
AbstractTransformFuture<I,O,F,T>	Implementations of Futures.transform*.
AbstractTransformFuture.AsyncTransformFuture<I,O>	An AbstractTransformFuture that delegates to an AsyncFunction and AbstractFuture.setFuture(ListenableFuture).
AbstractTransformFuture.TransformFuture<I,O>	An AbstractTransformFuture that delegates to a Function and AbstractFuture.set(Object).
AbstractUndirectedNetworkConnections<N,E>	A base implementation of NetworkConnections for undirected networks.
AbstractValueGraph<N,V>	This class provides a skeletal implementation of ValueGraph.
AggregateFuture<InputT,OutputT>	A future whose value is derived from a collection of input futures.
AggregateFuture.ReleaseResourcesReason
AggregateFutureState<OutputT>	A helper which does some thread-safe operations for aggregate futures, which must be implemented differently in GWT.
AggregateFutureState.AtomicHelper
AggregateFutureState.SafeAtomicHelper
AggregateFutureState.SynchronizedAtomicHelper
AllEqualOrdering	An ordering that treats all references as equals, even nulls.
AllowConcurrentEvents	Marks an event subscriber method as being thread-safe.
AnEnum	A sample enumerated type we use for testing.
AppendableWriter	Writer that places all output on an Appendable target.
ArbitraryInstances	Supplies an arbitrary "default" instance for a wide range of types, often useful in testing utilities.
ArbitraryInstances.AlwaysEqual
ArbitraryInstances.ByToString
ArbitraryInstances.Dummies
ArbitraryInstances.Dummies.DeterministicRandom
ArbitraryInstances.Dummies.DummyCountDownLatch
ArbitraryInstances.Dummies.DummyExecutor
ArbitraryInstances.Dummies.DummyRunnable
ArbitraryInstances.Dummies.DummyScheduledThreadPoolExecutor
ArbitraryInstances.Dummies.DummyThreadFactory
ArbitraryInstances.Dummies.InMemoryPrintStream
ArbitraryInstances.Dummies.InMemoryPrintWriter
ArbitraryInstances.NullByteSink
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.
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>
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.
BaseComparable	Simple base class to verify that we handle generics correctly.
BaseEncoding	A binary encoding scheme for reversibly translating between byte sequences and printable ASCII strings.
BaseEncoding.Alphabet
BaseEncoding.Base16Encoding
BaseEncoding.Base64Encoding
BaseEncoding.DecodingException	Exception indicating invalid base-encoded input encountered while decoding.
BaseEncoding.SeparatedBaseEncoding
BaseEncoding.StandardBaseEncoding
BaseGraph<N>	A non-public interface for the methods shared between Graph and ValueGraph.
BaseImmutableMultimap<K,V>	A dummy superclass of ImmutableMultimap that can be instanceof'd without ProGuard retaining additional implementation details of ImmutableMultimap.
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.
BiMapClearTester<K,V>	Tester for BiMap.clear.
BiMapEntrySetTester<K,V>	Tester for BiMap.entrySet and methods on the entries in the set.
BiMapGenerators	Generators of various BiMaps and derived collections.
BiMapGenerators.ImmutableBiMapCopyOfEntriesGenerator
BiMapGenerators.ImmutableBiMapCopyOfGenerator
BiMapGenerators.ImmutableBiMapGenerator
BiMapInverseTester<K,V>	Tests for the inverse view of a BiMap.
BiMapInverseTester.BiMapPair<K,V>
BiMapPutTester<K,V>	Tester for BiMap.put and BiMap.forcePut.
BiMapRemoveTester<K,V>	Tester for BiMap.remove.
BiMapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a BiMap implementation.
BiMapTestSuiteBuilder.NoRecurse
BloomFilter<T>	A Bloom filter for instances of T.
BloomFilter.SerialForm<T>
BloomFilter.Strategy	A strategy to translate T instances, to numHashFunctions bit indexes.
BloomFilterStrategies	Collections of strategies of generating the k * log(M) bits required for an element to be mapped to a BloomFilter of M bits and k hash functions.
BloomFilterStrategies.LockFreeBitArray	Models a lock-free array of bits.
Booleans	Static utility methods pertaining to boolean primitives, that are not already found in either Boolean or Arrays.
Booleans.BooleanArrayAsList
Booleans.BooleanComparator	Comparators for Boolean values.
Booleans.LexicographicalComparator
BoundType	Indicates whether an endpoint of some range is contained in the range itself ("closed") or not ("open").
ByFunctionOrdering<F,T>	An ordering that orders elements by applying an order to the result of a function on those elements.
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.
Bytes.ByteArrayAsList
ByteSink	A destination to which bytes can be written, such as a file.
ByteSource	A readable source of bytes, such as a file.
ByteSource.ByteArrayByteSource
ByteSource.ConcatenatedByteSource
ByteSource.EmptyByteSource
ByteStreams	Provides utility methods for working with byte arrays and I/O streams.
ByteStreams.ByteArrayDataInputStream
ByteStreams.ByteArrayDataOutputStream
ByteStreams.LimitedInputStream
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
CacheBuilder.NullListener
CacheBuilder.OneWeigher
CacheBuilderSpec	A specification of a CacheBuilder configuration.
CacheBuilderSpec.AccessDurationParser	Parse expireAfterAccess
CacheBuilderSpec.ConcurrencyLevelParser	Parse concurrencyLevel
CacheBuilderSpec.DurationParser	Base class for parsing times with durations
CacheBuilderSpec.InitialCapacityParser	Parse initialCapacity
CacheBuilderSpec.IntegerParser	Base class for parsing integers.
CacheBuilderSpec.KeyStrengthParser	Parse weakKeys
CacheBuilderSpec.LongParser	Base class for parsing integers.
CacheBuilderSpec.MaximumSizeParser	Parse maximumSize
CacheBuilderSpec.MaximumWeightParser	Parse maximumWeight
CacheBuilderSpec.RecordStatsParser	Parse recordStats
CacheBuilderSpec.RefreshDurationParser	Parse refreshAfterWrite
CacheBuilderSpec.ValueParser	Parses a single value.
CacheBuilderSpec.ValueStrengthParser	Parse weakValues and softValues
CacheBuilderSpec.WriteDurationParser	Parse expireAfterWrite
CacheLoader<K,V>	Computes or retrieves values, based on a key, for use in populating a LoadingCache.
CacheLoader.FunctionToCacheLoader<K,V>
CacheLoader.InvalidCacheLoadException	Thrown to indicate that an invalid response was returned from a call to CacheLoader.
CacheLoader.SupplierToCacheLoader<V>
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.
CartesianList<E>	Implementation of Lists.cartesianProduct(List).
CaseFormat	Utility class for converting between various ASCII case formats.
CaseFormat.StringConverter
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.
CharEscaperBuilder.CharArrayDecorator	Simple decorator that turns an array of replacement char[]s into a CharEscaper, this results in a very fast escape method.
CharMatcher	Determines a true or false value for any Java char value, just as Predicate does for any Object.
CharMatcher.And	Implementation of CharMatcher.and(CharMatcher).
CharMatcher.Any	Implementation of CharMatcher.any().
CharMatcher.AnyOf	Implementation of CharMatcher.anyOf(CharSequence) for three or more characters.
CharMatcher.Ascii	Implementation of CharMatcher.ascii().
CharMatcher.BitSetMatcher	Fast matcher using a BitSet table of matching characters.
CharMatcher.BreakingWhitespace	Implementation of CharMatcher.breakingWhitespace().
CharMatcher.Digit	Implementation of CharMatcher.digit().
CharMatcher.FastMatcher	A matcher for which precomputation will not yield any significant benefit.
CharMatcher.ForPredicate	Implementation of CharMatcher.forPredicate(Predicate).
CharMatcher.InRange	Implementation of CharMatcher.inRange(char, char).
CharMatcher.Invisible	Implementation of CharMatcher.invisible().
CharMatcher.Is	Implementation of CharMatcher.is(char).
CharMatcher.IsEither	Implementation of CharMatcher.anyOf(CharSequence) for exactly two characters.
CharMatcher.IsNot	Implementation of CharMatcher.isNot(char).
CharMatcher.JavaDigit	Implementation of CharMatcher.javaDigit().
CharMatcher.JavaIsoControl	Implementation of CharMatcher.javaIsoControl().
CharMatcher.JavaLetter	Implementation of CharMatcher.javaLetter().
CharMatcher.JavaLetterOrDigit	Implementation of CharMatcher.javaLetterOrDigit().
CharMatcher.JavaLowerCase	Implementation of CharMatcher.javaLowerCase().
CharMatcher.JavaUpperCase	Implementation of CharMatcher.javaUpperCase().
CharMatcher.NamedFastMatcher	CharMatcher.FastMatcher which overrides toString() with a custom name.
CharMatcher.Negated	Implementation of CharMatcher.Negated.negate().
CharMatcher.NegatedFastMatcher	Negation of a CharMatcher.FastMatcher.
CharMatcher.None	Implementation of CharMatcher.none().
CharMatcher.Or	Implementation of CharMatcher.or(CharMatcher).
CharMatcher.RangesMatcher	Implementation that matches characters that fall within multiple ranges.
CharMatcher.SingleWidth	Implementation of CharMatcher.singleWidth().
CharMatcher.Whitespace	Implementation of CharMatcher.whitespace().
Chars	Static utility methods pertaining to char primitives, that are not already found in either Character or Arrays.
Chars.CharArrayAsList
Chars.LexicographicalComparator
CharSequenceReader	A Reader that reads the characters in a CharSequence.
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.
CharSource.CharSequenceCharSource
CharSource.ConcatenatedCharSource
CharSource.EmptyCharSource
CharSource.StringCharSource	Subclass specialized for string instances.
CharStreams	Provides utility methods for working with character streams.
CharStreams.NullWriter
ChecksumHashFunction	HashFunction adapter for Checksum instances.
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.DefaultScanner
ClassPath.ResourceInfo	Represents a class path resource that can be either a class file or any other resource file loadable from the class path.
ClassPath.Scanner	Abstract class that scans through the class path represented by a ClassLoader and calls ClassPath.Scanner.scanDirectory(java.lang.ClassLoader, java.io.File) and ClassPath.Scanner.scanJarFile(java.lang.ClassLoader, java.util.jar.JarFile) for directories and jar files on the class path respectively.
ClassSanityTester	Tester that runs automated sanity tests for any given class.
ClassSanityTester.FactoryMethodReturnsNullException	Thrown if the test tries to invoke a static factory method to test instance methods but the factory returned null.
ClassSanityTester.ParameterHasNoDistinctValueException	Thrown if the test fails to generate two distinct non-null values of a constructor or factory parameter in order to test Object.equals(java.lang.Object) and Object.hashCode() of the declaring class.
ClassSanityTester.ParameterNotInstantiableException	Thrown if the test tries to invoke a constructor or static factory method but failed because the dummy value of a constructor or method parameter is unknown.
ClassSanityTester.SerializableDummyProxy
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.
Closer.LoggingSuppressor	Suppresses exceptions by logging them.
Closer.SuppressingSuppressor	Suppresses exceptions by adding them to the exception that will be thrown using JDK7's addSuppressed(Throwable) mechanism.
Closer.Suppressor	Suppression strategy interface.
ClusterException	An ClusterException is a data structure that allows for some code to "throw multiple exceptions", or something close to it.
CollectCollectors	Collectors utilities for common.collect internals.
CollectionAddAllTester<E>	A generic JUnit test which tests addAll operations on a collection.
CollectionAddTester<E>	A generic JUnit test which tests add operations on a collection.
CollectionClearTester<E>	A generic JUnit test which tests clear() operations on a collection.
CollectionContainsAllTester<E>	A generic JUnit test which tests containsAll() operations on a collection.
CollectionContainsTester<E>	A generic JUnit test which tests contains() operations on a collection.
CollectionCreationTester<E>	A generic JUnit test which tests creation (typically through a constructor or static factory method) of a collection.
CollectionEqualsTester<E>	Tests Collection.equals(java.lang.Object).
CollectionFeature	Optional features of classes derived from Collection.
CollectionFeature.Require
CollectionForEachTester<E>	A generic JUnit test which tests forEach operations on a collection.
CollectionFuture<V,C>	Aggregate future that collects (stores) results of each future.
CollectionFuture.ListFuture<V>	Used for Futures.allAsList(com.google.common.util.concurrent.ListenableFuture<? extends V>...) and Futures.successfulAsList(com.google.common.util.concurrent.ListenableFuture<? extends V>...).
CollectionFuture.Present<V>	The result of a successful Future.
CollectionIsEmptyTester<E>	A generic JUnit test which tests isEmpty() operations on a collection.
CollectionIteratorTester<E>	A generic JUnit test which tests iterator operations on a collection.
CollectionRemoveAllTester<E>	A generic JUnit test which tests removeAll operations on a collection.
CollectionRemoveIfTester<E>	A generic JUnit test which tests Collection.removeIf(java.util.function.Predicate<? super E>).
CollectionRemoveTester<E>	A generic JUnit test which tests remove operations on a collection.
CollectionRetainAllTester<E>	A generic JUnit test which tests retainAll operations on a collection.
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>
CollectionSerializationEqualTester<E>	Basic reserialization test for collection types that must preserve equals() behavior when reserialized.
CollectionSerializationTester<E>	Basic reserialization test for collections.
CollectionSize	When describing the features of the collection produced by a given generator (i.e.
CollectionSize.Require
CollectionSizeTester<E>	A generic JUnit test which tests size() operations on a collection.
CollectionSpliteratorTester<E>	A generic JUnit test which tests spliterator operations on a collection.
CollectionStreamTester<E>	A generic JUnit test which tests stream operations on a collection.
CollectionTestSuiteBuilder<E>	Concrete instantiation of AbstractCollectionTestSuiteBuilder for testing collections that do not have a more specific tester like ListTestSuiteBuilder or SetTestSuiteBuilder.
CollectionTestSuiteBuilder.ReserializedCollectionGenerator<E>
CollectionToArrayTester<E>	A generic JUnit test which tests toArray() operations on a collection.
CollectionToStringTester<E>	A generic JUnit test which tests toString() operations on a collection.
CollectorTester<T,A,R>	Tester for Collector implementations.
CollectorTester.CollectStrategy	Different orderings for combining the elements of an input array, which must all produce the same result.
CollectPreconditions	Precondition checks useful in collection implementations.
CollectSpliterators	Spliterator utilities for common.collect internals.
CollectSpliterators.FlatMapSpliterator<InElementT,OutElementT,OutSpliteratorT extends java.util.Spliterator<OutElementT>>	Implements the Stream#flatMap operation on spliterators.
CollectSpliterators.FlatMapSpliterator.Factory<InElementT,OutSpliteratorT extends java.util.Spliterator<?>>	Factory for constructing CollectSpliterators.FlatMapSpliterator instances.
CollectSpliterators.FlatMapSpliteratorOfDouble<InElementT>	Implementation of CollectSpliterators.flatMapToDouble(java.util.Spliterator<InElementT>, java.util.function.Function<? super InElementT, java.util.Spliterator.OfDouble>, int, long).
CollectSpliterators.FlatMapSpliteratorOfInt<InElementT>	Implementation of CollectSpliterators.flatMapToInt(java.util.Spliterator<InElementT>, java.util.function.Function<? super InElementT, java.util.Spliterator.OfInt>, int, long).
CollectSpliterators.FlatMapSpliteratorOfLong<InElementT>	Implementation of CollectSpliterators.flatMapToLong(java.util.Spliterator<InElementT>, java.util.function.Function<? super InElementT, java.util.Spliterator.OfLong>, int, long).
CollectSpliterators.FlatMapSpliteratorOfObject<InElementT,OutElementT>	Implementation of Stream#flatMap with an object spliterator output type.
CollectSpliterators.FlatMapSpliteratorOfPrimitive<InElementT,OutElementT,OutConsumerT,OutSpliteratorT extends java.util.Spliterator.OfPrimitive<OutElementT,OutConsumerT,OutSpliteratorT>>	Implementation of Stream#flatMap with a primitive spliterator output type.
CombinedFuture<V>	Aggregate future that computes its value by calling a callable.
CommonMatcher	The subset of the Matcher API which is used by this package, and also shared with the re2j library.
CommonPattern	The subset of the Pattern API which is used by this package, and also shared with the re2j library.
CompactHashing	Helper classes and static methods for implementing compact hash-based collections.
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.
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).
ConcurrentHashMultiset.FieldSettersHolder
ConcurrentMapPutIfAbsentTester<K,V>	A generic JUnit test which tests putIfAbsent operations on a concurrent map.
ConcurrentMapRemoveTester<K,V>	Tester for ConcurrentMap.remove(java.lang.Object, java.lang.Object).
ConcurrentMapReplaceEntryTester<K,V>	A generic JUnit test which tests replace(K, V, V) operations on a concurrent map.
ConcurrentMapReplaceTester<K,V>	A generic JUnit test which tests replace(K, V) operations on a concurrent map.
ConcurrentMapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a ConcurrentMap implementation.
ConcurrentNavigableMapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a ConcurrentNavigableMap implementation.
ConflictingRequirementsException	Thrown when requirements on a tester method or class conflict with each other.
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.
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.
Converter.ConverterComposition<A,B,C>
Converter.FunctionBasedConverter<A,B>
Converter.IdentityConverter<T>	A converter that always converts or reverses an object to itself.
Converter.ReverseConverter<A,B>
Count	A mutable value of type int, for multisets to use in tracking counts of values.
CountingInputStream	An InputStream that counts the number of bytes read.
CountingOutputStream	An OutputStream that counts the number of bytes written.
Crc32cHashFunction	This class generates a CRC32C checksum, defined by RFC 3720, Section 12.1.
Crc32cHashFunction.Crc32cHasher
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>
CycleDetectingLockFactory	The CycleDetectingLockFactory creates ReentrantLock instances and ReentrantReadWriteLock instances that detect potential deadlock by checking for cycles in lock acquisition order.
CycleDetectingLockFactory.CycleDetectingLock	Internal Lock implementations implement the CycleDetectingLock interface, allowing the detection logic to treat all locks in the same manner.
CycleDetectingLockFactory.ExampleStackTrace	A Throwable used to record a stack trace that illustrates an example of a specific lock acquisition ordering.
CycleDetectingLockFactory.LockGraphNode	A LockGraphNode associated with each lock instance keeps track of the directed edges in the lock acquisition graph.
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.
DenseImmutableTable<R,C,V>	A RegularImmutableTable optimized for dense data.
DenseImmutableTable.ImmutableArrayMap<K,V>	An immutable map implementation backed by an indexed nullable array.
DerivedCollectionGenerators	Derived suite generators, split out of the suite builders so that they are available to GWT.
DerivedCollectionGenerators.Bound	Two bounds (from and to) define how to build a subMap.
DerivedCollectionGenerators.ForwardingTestMapGenerator<K,V>
DerivedCollectionGenerators.MapEntrySetGenerator<K,V>
DerivedCollectionGenerators.MapKeySetGenerator<K,V>
DerivedCollectionGenerators.MapSortedKeySetGenerator<K,V>
DerivedCollectionGenerators.MapValueCollectionGenerator<K,V>
DerivedCollectionGenerators.SortedMapSubmapTestMapGenerator<K,V>
DerivedCollectionGenerators.SortedSetSubsetTestSetGenerator<E>
DerivedComparable	Simple derived class to verify that we handle generics correctly.
DerivedGenerator	A generator that relies on a preexisting generator for most of its work.
DerivedGoogleCollectionGenerators	Derived suite generators for Guava collection interfaces, split out of the suite builders so that they are available to GWT.
DerivedGoogleCollectionGenerators.BiMapValueSetGenerator<K,V>
DerivedGoogleCollectionGenerators.InverseBiMapGenerator<K,V>
DerivedGoogleCollectionGenerators.MapGenerator<K,V>
DerivedTestIteratorGenerator<E>	Adapts a test iterable generator to give a TestIteratorGenerator.
DescendingImmutableSortedMultiset<E>	A descending wrapper around an ImmutableSortedMultiset
DescendingImmutableSortedSet<E>	Skeletal implementation of ImmutableSortedSet.descendingSet().
DescendingMultiset<E>	A skeleton implementation of a descending multiset.
DirectedGraphConnections<N,V>	An implementation of GraphConnections for directed graphs.
DirectedGraphConnections.NodeConnection<N>	A value class representing single connection between the origin node and another node.
DirectedGraphConnections.NodeConnection.Pred<N>
DirectedGraphConnections.NodeConnection.Succ<N>
DirectedGraphConnections.PredAndSucc	A wrapper class to indicate a node is both a predecessor and successor while still providing the successor value.
DirectedMultiNetworkConnections<N,E>	An implementation of NetworkConnections for directed networks with parallel edges.
DirectedNetworkConnections<N,E>	An implementation of NetworkConnections for directed networks.
DirectExecutor	An Executor that runs each task in the thread that invokes execute.
DiscreteDomain<C extends java.lang.Comparable>	A descriptor for a discrete Comparable domain such as all Integer instances.
DiscreteDomain.BigIntegerDomain
DiscreteDomain.IntegerDomain
DiscreteDomain.LongDomain
Dispatcher	Handler for dispatching events to subscribers, providing different event ordering guarantees that make sense for different situations.
Dispatcher.ImmediateDispatcher	Implementation of Dispatcher.immediate().
Dispatcher.LegacyAsyncDispatcher	Implementation of a Dispatcher.legacyAsync() dispatcher.
Dispatcher.LegacyAsyncDispatcher.EventWithSubscriber
Dispatcher.PerThreadQueuedDispatcher	Implementation of a Dispatcher.perThreadDispatchQueue() dispatcher.
Dispatcher.PerThreadQueuedDispatcher.Event
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.
Doubles.DoubleArrayAsList
Doubles.DoubleConverter
Doubles.LexicographicalComparator
DoublesMethodsForWeb	Holder for web specializations of methods of Doubles.
DoubleUtils	Utilities for double primitives.
DummyProxy	Generates a dummy interface proxy that simply returns a dummy value for each method.
EdgesConnecting<E>	A class to represent the set of edges connecting an (implicit) origin node to a target node.
Element	Represents either a Field, a Method or a Constructor.
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.
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.
EndpointPair<N>	An immutable pair representing the two endpoints of an edge in a graph.
EndpointPair.Ordered<N>
EndpointPair.Unordered<N>
EndpointPairIterator<N>	A class to facilitate the set returned by Graph.edges().
EndpointPairIterator.Directed<N>	If the graph is directed, each ordered [source, target] pair will be visited once if there is an edge connecting them.
EndpointPairIterator.Undirected<N>	If the graph is undirected, each unordered [node, otherNode] pair (except self-loops) will be visited twice if there is an edge connecting them.
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.
Enums.StringConverter<T extends java.lang.Enum<T>>
EqualsTester	Tester for equals() and hashCode() methods of a class.
EqualsTester.NotAnInstance	Class used to test whether equals() correctly handles an instance of an incompatible class.
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.Equals
Equivalence.EquivalentToPredicate<T>
Equivalence.Identity
Equivalence.Wrapper<T>	Wraps an object so that Equivalence.Wrapper.equals(Object) and Equivalence.Wrapper.hashCode() delegate to an Equivalence.
EquivalenceTester<T>	Tester for Equivalence relationships between groups of objects.
Escaper	An object that converts literal text into a format safe for inclusion in a particular context (such as an XML document).
EscaperAsserts	Extra assert methods for testing Escaper implementations.
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.
EventBus.LoggingHandler	Simple logging handler for subscriber exceptions.
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.
ExecutionList.RunnableExecutorPair
ExecutionSequencer	Serializes execution of a set of operations.
ExecutionSequencer.RunningState
ExplicitOrdering<T>	An ordering that compares objects according to a given order.
ExtraObjectsMethodsForWeb	Holder for extra methods of Objects only in web.
FakeTicker	A Ticker whose value can be advanced programmatically in test.
FakeTimeLimiter	A TimeLimiter implementation which actually does not attempt to limit time at all.
FarmHashFingerprint64	Implementation of FarmHash Fingerprint64, an open-source fingerprinting algorithm for strings.
Feature<T>	Base class for enumerating the features of an interface to be tested.
FeatureSpecificTestSuiteBuilder<B extends FeatureSpecificTestSuiteBuilder<B,G>,G>	Creates, based on your criteria, a JUnit test suite that exhaustively tests the object generated by a G, selecting appropriate tests by matching them against specified features.
FeatureUtil	Utilities for collecting and validating tester requirements from annotations.
FileBackedOutputStream	An OutputStream that starts buffering to a byte array, but switches to file buffering once the data reaches a configurable size.
FileBackedOutputStream.MemoryOutput	ByteArrayOutputStream that exposes its internals.
Files	Provides utility methods for working with files.
Files.FileByteSink
Files.FileByteSource
Files.FilePredicate
FileWriteMode	Modes for opening a file for writing.
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).
FilteredMultimap<K,V>	An interface for all filtered multimap types.
FilteredMultimapValues<K,V>	Implementation for Multimap.values().
FilteredSetMultimap<K,V>	A supertype for filtered SetMultimap implementations.
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.
FinalizableReferenceQueue.DecoupledLoader	Try to load Finalizer in its own class loader.
FinalizableReferenceQueue.DirectLoader	Loads Finalizer directly using the current class loader.
FinalizableReferenceQueue.FinalizerLoader	Loads Finalizer.class.
FinalizableReferenceQueue.SystemLoader	Tries to load Finalizer from the system class loader.
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.
Finalizer	Thread that finalizes referents.
Floats	Static utility methods pertaining to float primitives, that are not already found in either Float or Arrays.
Floats.FloatArrayAsList
Floats.FloatConverter
Floats.LexicographicalComparator
FloatsMethodsForWeb	Holder for web specializations of methods of Floats.
FluentFuture<V>	A ListenableFuture that supports fluent chains of operations.
FluentFuture.TrustedFuture<V>	A less abstract subclass of AbstractFuture.
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.
Flushables	Utility methods for working with Flushable objects.
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.
ForwardingCondition	Forwarding wrapper around a Condition.
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.
ForwardingFluentFuture<V>	FluentFuture that forwards all calls to a delegate.
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.
ForwardingGraph<N>	A class to allow Graph implementations to be backed by a BaseGraph.
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.
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.
ForwardingLock	Forwarding wrapper around a Lock.
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.
ForwardingNetwork<N,E>	A class to allow Network implementations to be backed by a provided delegate.
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.
ForwardingValueGraph<N,V>	A class to allow ValueGraph implementations to be backed by a provided delegate.
ForwardingWrapperTester	Tester to ensure forwarding wrapper works by delegating calls to the corresponding method with the same parameters forwarded and return value forwarded back or exception propagated as is.
ForwardingWrapperTester.InteractionTester<T>	Tests a single interaction against a method.
FreshValueGenerator	Generates fresh instances of types that are different from each other (if possible).
FreshValueGenerator.Empty	Annotates a method to generate the "empty" instance of a collection.
FreshValueGenerator.Generates	Annotates a method to be the instance generator of a certain type.
Function<F,T>	Legacy version of java.util.function.Function.
FunctionalEquivalence<F,T>	Equivalence applied on functional result.
Functions	Static utility methods pertaining to com.google.common.base.Function instances; see that class for information about migrating to java.util.function.
Functions.ConstantFunction<E>
Functions.ForMapWithDefault<K,V>
Functions.FunctionComposition<A,B,C>
Functions.FunctionForMapNoDefault<K,V>
Functions.IdentityFunction
Functions.PredicateFunction<T>
Functions.SupplierFunction<T>
Functions.ToStringFunction
Funnel<T>	An object which can send data from an object of type T into a PrimitiveSink.
Funnels	Funnels for common types.
Funnels.ByteArrayFunnel
Funnels.IntegerFunnel
Funnels.LongFunnel
Funnels.SequentialFunnel<E>
Funnels.SinkAsStream
Funnels.StringCharsetFunnel
Funnels.StringCharsetFunnel.SerializedForm
Funnels.UnencodedCharsFunnel
FutureCallback<V>	A callback for accepting the results of a Future computation asynchronously.
Futures	Static utility methods pertaining to the Future interface.
Futures.CallbackListener<V>	See Futures.addCallback(ListenableFuture, FutureCallback, Executor) for behavioral notes.
Futures.FutureCombiner<V>	A helper to create a new ListenableFuture whose result is generated from a combination of input futures.
Futures.InCompletionOrderFuture<T>
Futures.InCompletionOrderState<T>
Futures.NonCancellationPropagatingFuture<V>	A wrapped future that does not propagate cancellation to its delegate.
FuturesGetChecked	Static methods used to implement Futures.getChecked(Future, Class).
FuturesGetChecked.GetCheckedTypeValidator
FuturesGetChecked.GetCheckedTypeValidatorHolder	Provides a check of whether an exception type is valid for use with FuturesGetChecked.getChecked(Future, Class), possibly using caching.
FuturesGetChecked.GetCheckedTypeValidatorHolder.ClassValueValidator
FuturesGetChecked.GetCheckedTypeValidatorHolder.WeakSetValidator
GcFinalization	Testing utilities relating to garbage collection finalization.
GcFinalization.FinalizationPredicate	A predicate that is expected to return true subsequent to finalization, that is, one of the following actions taken by the garbage collector when performing a full collection in response to System.gc(): invoking the finalize methods of unreachable objects clearing weak references to unreachable referents enqueuing weak references to unreachable referents in their reference queue
GeneralRange<T>	A generalized interval on any ordering, for internal use.
GoogleHelpers	Helper methods/assertions for use with com.google.common.collect types.
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.
GraphConnections<N,V>	An interface for representing and manipulating an origin node's adjacent nodes and edge values in a Graph.
GraphConstants	A utility class to hold various constants used by the Guava Graph library.
GraphConstants.Presence	Singleton edge value for Graph implementations backed by ValueGraphs.
Graphs	Static utility methods for Graph, ValueGraph, and Network instances.
Graphs.NodeVisitState	An enum representing the state of a node during DFS.
Graphs.TransposedGraph<N>
Graphs.TransposedNetwork<N,E>
Graphs.TransposedValueGraph<N,V>
GwtCompatible	The presence of this annotation on a type indicates that the type may be used with the Google Web Toolkit (GWT).
GwtFluentFutureCatchingSpecialization<V>	Hidden superclass of FluentFuture that provides us a place to declare special GWT versions of the FluentFuture.catching family of methods.
GwtFuturesCatchingSpecialization	Hidden superclass of Futures that provides us a place to declare special GWT versions of the Futures.catching family of methods.
GwtIncompatible	The presence of this annotation on an API indicates that the method may not be used with the Google Web Toolkit (GWT).
GwtTransient	Private replacement for com.google.gwt.user.client.rpc.GwtTransient to work around build-system quirks.
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>
HashCode	An immutable hash code of arbitrary bit length.
HashCode.BytesHashCode
HashCode.IntHashCode
HashCode.LongHashCode
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 for implementing hash-based collections.
Hashing	Static methods to obtain HashFunction instances, and other static hashing-related utilities.
Hashing.ChecksumType
Hashing.ConcatenatedHashFunction
Hashing.LinearCongruentialGenerator	Linear CongruentialGenerator to use for consistent hashing.
Hashing.Md5Holder
Hashing.Sha1Holder
Hashing.Sha256Holder
Hashing.Sha384Holder
Hashing.Sha512Holder
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.
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.
Helpers
Helpers.GwtTransient	Private replacement for com.google.gwt.user.client.rpc.GwtTransient to work around build-system quirks.
Helpers.NullsBefore	Compares strings in natural order except that null comes immediately before a given value.
Helpers.NullsBeforeB
Helpers.NullsBeforeTwo
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.
IgnoreJRERequirement
ImmediateFuture<V>	Implementation of Futures.immediateFuture(V).
ImmediateFuture.ImmediateCancelledFuture<V>
ImmediateFuture.ImmediateFailedFuture<V>
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.
ImmutableDoubleArray	An immutable array of double values, with an API resembling List.
ImmutableDoubleArray.AsList
ImmutableDoubleArray.Builder	A builder for ImmutableDoubleArray instances; obtained using ImmutableDoubleArray.builder(int).
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>>
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.AsList
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").
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").
ImmutableLongArray	An immutable array of long values, with an API resembling List.
ImmutableLongArray.AsList
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").
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.
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.
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.
ImmutableSupplier<T>	Explicitly named subinterface of Supplier that can be marked @Immutable.
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.
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.
IncidentEdgeSet<N>	Abstract base class for an incident edges set that allows different implementations of AbstractCollection.iterator().
IndexedImmutableSet<E>
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.
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).
Internal	This class is for com.google.common.util.concurrent use only!
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.
Interners.InternerFunction<E>
Interners.InternerImpl<E>
InternetDomainName	An immutable well-formed internet domain name, such as com or foo.co.uk.
InterruptibleTask<T>
InterruptibleTask.DoNothingRunnable
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.
Ints.IntArrayAsList
Ints.IntConverter
Ints.LexicographicalComparator
IntsMethodsForWeb	Holder for web specializations of methods of Ints.
Invokable<T,R>	Wrapper around either a Method or a Constructor.
Invokable.ConstructorInvokable<T>
Invokable.MethodInvokable<T>
Iterables	An assortment of mainly legacy static utility methods that operate on or return objects of type Iterable.
Iterables.UnmodifiableIterable<T>
IteratorFeature	A method supported by implementations of the Iterator or ListIterator interface.
Iterators	This class contains static utility methods that operate on or return objects of type Iterator.
Iterators.ArrayItr<T>
Iterators.ConcatenatedIterator<T>
Iterators.EmptyModifiableIterator	This is an enum singleton rather than an anonymous class so ProGuard can figure out it's only referenced by emptyModifiableIterator().
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.
IteratorTester<E>	A utility for testing an Iterator implementation by comparing its behavior to that of a "known good" reference implementation.
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.
JdkFutureAdapters	Utilities necessary for working with libraries that supply plain Future instances.
JdkFutureAdapters.ListenableFutureAdapter<V>	An adapter to turn a Future into a ListenableFuture.
JdkPattern	A regex pattern implementation which is backed by the Pattern.
JdkPattern.JdkMatcher
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.
LexicographicalOrdering<T>	An ordering which sorts iterables by comparing corresponding elements pairwise.
LinearTransformation	The representation of a linear transformation between real numbers x and y.
LinearTransformation.LinearTransformationBuilder	This is an intermediate stage in the construction process.
LinearTransformation.NaNLinearTransformation
LinearTransformation.RegularLinearTransformation
LinearTransformation.VerticalLinearTransformation
LineBuffer	Package-protected abstract class that implements the line reading algorithm used by LineReader.
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.
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.
LinkedHashMultimap.ValueSetLink<K,V>
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>
ListAddAllAtIndexTester<E>	A generic JUnit test which tests addAll(int, Collection) operations on a list.
ListAddAllTester<E>	A generic JUnit test which tests addAll(Collection) operations on a list.
ListAddAtIndexTester<E>	A generic JUnit test which tests add(int, Object) operations on a list.
ListAddTester<E>	A generic JUnit test which tests add(Object) operations on a list.
ListCreationTester<E>	A generic JUnit test which tests creation (typically through a constructor or static factory method) of a list.
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.
ListenerCallQueue<L>	A list of listeners for implementing a concurrency friendly observable object.
ListenerCallQueue.Event<L>	Method reference-compatible listener event.
ListenerCallQueue.PerListenerQueue<L>	A special purpose queue/executor that dispatches listener events serially on a configured executor.
ListeningExecutorService	An ExecutorService that returns ListenableFuture instances.
ListeningScheduledExecutorService	A ScheduledExecutorService that returns ListenableFuture instances from its ExecutorService methods.
ListEqualsTester<E>	Tests List.equals(java.lang.Object).
ListFeature	Optional features of classes derived from List.
ListFeature.Require
ListGenerators	Common generators of different types of lists.
ListGenerators.BuilderAddAllListGenerator
ListGenerators.BuilderAddListGenerator
ListGenerators.BuilderReversedListGenerator
ListGenerators.CharactersOfCharSequenceGenerator
ListGenerators.CharactersOfStringGenerator
ListGenerators.ImmutableListHeadSubListGenerator
ListGenerators.ImmutableListMiddleSubListGenerator
ListGenerators.ImmutableListOfGenerator
ListGenerators.ImmutableListTailSubListGenerator
ListGenerators.TestUnhashableListGenerator
ListGenerators.UnhashableElementsImmutableListGenerator
ListGetTester<E>	A generic JUnit test which tests get() operations on a list.
ListHashCodeTester<E>	Tests List.hashCode().
ListIndexOfTester<E>	A generic JUnit test which tests indexOf() operations on a list.
ListIteratorTester<E>	A utility similar to IteratorTester for testing a ListIterator against a known good reference implementation.
ListLastIndexOfTester<E>	A generic JUnit test which tests lastIndexOf() operations on a list.
ListListIteratorTester<E>	A generic JUnit test which tests listIterator operations on a list.
ListMultimap<K,V>	A Multimap that can hold duplicate key-value pairs and that maintains the insertion ordering of values for a given key.
ListMultimapAsMapTester<K,V>	Testers for ListMultimap.asMap().
ListMultimapEqualsTester<K,V>	Testers for ListMultimap.equals(Object).
ListMultimapPutAllTester<K,V>	Testers for Multimap.putAll(Object, Iterable).
ListMultimapPutTester<K,V>	Testers for Multimap.put(Object, Object).
ListMultimapRemoveTester<K,V>	Testers for Multimap.remove(Object, Object).
ListMultimapReplaceValuesTester<K,V>	Testers for ListMultimap.replaceValues(Object, Iterable).
ListMultimapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a ListMultimap implementation.
ListMultimapTestSuiteBuilder.MultimapAsMapGetGenerator<K,V>
ListMultimapTestSuiteBuilder.MultimapGetGenerator<K,V>
ListRemoveAllTester<E>	A generic JUnit test which tests removeAll operations on a list.
ListRemoveAtIndexTester<E>	A generic JUnit test which tests remove(int) operations on a list.
ListRemoveTester<E>	A generic JUnit test which tests remove(Object) operations on a list.
ListReplaceAllTester<E>	A generic JUnit test which tests List.replaceAll(java.util.function.UnaryOperator<E>).
ListRetainAllTester<E>	A generic JUnit test which tests retainAll operations on a list.
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>
ListSetTester<E>	A generic JUnit test which tests set() operations on a list.
ListSubListTester<E>	A generic JUnit test which tests subList() operations on a list.
ListTestSuiteBuilder<E>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a List implementation.
ListTestSuiteBuilder.ReserializedListGenerator<E>
ListToArrayTester<E>	A generic JUnit test which tests toArray() operations on a list.
LittleEndianByteArray	Utility functions for loading and storing values from a byte array.
LittleEndianByteArray.JavaLittleEndianBytes	Fallback implementation for when Unsafe is not available in our current environment.
LittleEndianByteArray.LittleEndianBytes	Common interface for retrieving a 64-bit long from a little-endian byte array.
LittleEndianByteArray.UnsafeByteArray	The only reference to Unsafe is in this nested class.
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.
LocalCache<K,V>	The concurrent hash map implementation built by CacheBuilder.
LocalCache.AbstractReferenceEntry<K,V>
LocalCache.AccessQueue<K,V>	A custom queue for managing access order.
LocalCache.EntryFactory	Creates new entries.
LocalCache.LoadingSerializationProxy<K,V>	Serializes the configuration of a LocalCache, reconstituting it as an LoadingCache using CacheBuilder upon deserialization.
LocalCache.LoadingValueReference<K,V>
LocalCache.LocalLoadingCache<K,V>
LocalCache.LocalManualCache<K,V>
LocalCache.ManualSerializationProxy<K,V>	Serializes the configuration of a LocalCache, reconstituting it as a Cache using CacheBuilder upon deserialization.
LocalCache.NullEntry
LocalCache.Segment<K,V>	Segments are specialized versions of hash tables.
LocalCache.SoftValueReference<K,V>	References a soft value.
LocalCache.Strength
LocalCache.StrongAccessEntry<K,V>
LocalCache.StrongAccessWriteEntry<K,V>
LocalCache.StrongEntry<K,V>	Used for strongly-referenced keys.
LocalCache.StrongValueReference<K,V>	References a strong value.
LocalCache.StrongWriteEntry<K,V>
LocalCache.ValueReference<K,V>	A reference to a value.
LocalCache.WeakAccessEntry<K,V>
LocalCache.WeakAccessWriteEntry<K,V>
LocalCache.WeakEntry<K,V>	Used for weakly-referenced keys.
LocalCache.WeakValueReference<K,V>	References a weak value.
LocalCache.WeakWriteEntry<K,V>
LocalCache.WeightedSoftValueReference<K,V>	References a soft value.
LocalCache.WeightedStrongValueReference<K,V>	References a strong value.
LocalCache.WeightedWeakValueReference<K,V>	References a weak value.
LocalCache.WriteQueue<K,V>	A custom queue for managing eviction order.
LongAddable	Abstract interface for objects that can concurrently add longs.
LongAddable	Abstract interface for objects that can concurrently add longs.
LongAddables	Source of LongAddable objects that deals with GWT, Unsafe, and all that.
LongAddables	Source of LongAddable objects that deals with GWT, Unsafe, and all that.
LongAddables.PureJavaLongAddable
LongAddables.PureJavaLongAddable
LongAdder	One or more variables that together maintain an initially zero long sum.
LongAdder	One or more variables that together maintain an initially zero long sum.
LongMath	A class for arithmetic on values of type long.
LongMath.MillerRabinTester
Longs	Static utility methods pertaining to long primitives, that are not already found in either Long or Arrays.
Longs.AsciiDigits
Longs.LexicographicalComparator
Longs.LongArrayAsList
Longs.LongConverter
MacHashFunction	HashFunction adapter for Mac instances.
MacHashFunction.MacHasher	Hasher that updates a Mac (message authentication code).
MapClearTester<K,V>	A generic JUnit test which tests clear() operations on a map.
MapComputeIfAbsentTester<K,V>	A generic JUnit test which tests Map.computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>).
MapComputeIfAbsentTester.ExpectedException
MapComputeIfPresentTester<K,V>	A generic JUnit test which tests Map.computeIfPresent(K, java.util.function.BiFunction<? super K, ? super V, ? extends V>).
MapComputeIfPresentTester.ExpectedException
MapComputeTester<K,V>	A generic JUnit test which tests Map.compute(K, java.util.function.BiFunction<? super K, ? super V, ? extends V>).
MapComputeTester.ExpectedException
MapContainsKeyTester<K,V>	A generic JUnit test which tests containsKey() operations on a map.
MapContainsValueTester<K,V>	A generic JUnit test which tests containsValue() operations on a map.
MapCreationTester<K,V>	A generic JUnit test which tests creation (typically through a constructor or static factory method) of a map.
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.
MapEntrySetTester<K,V>	Tests Map.entrySet().
MapEntrySetTester.IncomparableType
MapEqualsTester<K,V>	Tests Map.equals(java.lang.Object).
MapFeature	Optional features of classes derived from Map.
MapFeature.Require
MapForEachTester<K,V>	A generic JUnit test which tests Map.forEach(java.util.function.BiConsumer<? super K, ? super V>).
MapGenerators	Generators of different types of map and related collections, such as keys, entries and values.
MapGenerators.ImmutableEnumMapGenerator
MapGenerators.ImmutableMapCopyOfEntriesGenerator
MapGenerators.ImmutableMapCopyOfEnumMapGenerator
MapGenerators.ImmutableMapCopyOfGenerator
MapGenerators.ImmutableMapEntryListGenerator
MapGenerators.ImmutableMapGenerator
MapGenerators.ImmutableMapKeyListGenerator
MapGenerators.ImmutableMapUnhashableValuesGenerator
MapGenerators.ImmutableMapValueListGenerator
MapGenerators.ImmutableMapValuesAsSingletonSetGenerator
MapGetOrDefaultTester<K,V>	A generic JUnit test which tests Map.getOrDefault(java.lang.Object, V).
MapGetTester<K,V>	A generic JUnit test which tests get operations on a map.
MapHashCodeTester<K,V>	Tests Map.hashCode().
MapInterfaceTest<K,V>	Tests representing the contract of Map.
MapInterfaceTest.IncompatibleKeyType	A key type that is not assignable to any classes but Object.
MapIsEmptyTester<K,V>	A generic JUnit test which tests isEmpty() operations on a map.
MapIteratorCache<K,V>	A map-like data structure that wraps a backing map and caches values while iterating through MapIteratorCache.unmodifiableKeySet().
MapMaker	A builder of ConcurrentMap instances that can have keys or values automatically wrapped in weak references.
MapMaker.Dummy	A dummy singleton value type used by Interners.
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.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.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.Strength
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.StrongValueEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>>	Marker interface for MapMakerInternalMap.InternalEntry implementations for strong 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.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.
MapMakerInternalMap.WeakValueReferenceImpl<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>>	Concrete implementation of MapMakerInternalMap.WeakValueReference.
MapMergeTester<K,V>	A generic JUnit test which tests Map.merge(K, V, java.util.function.BiFunction<? super V, ? super V, ? extends V>).
MapMergeTester.ExpectedException
MapPutAllTester<K,V>	A generic JUnit test which tests putAll operations on a map.
MapPutIfAbsentTester<K,V>	A generic JUnit test which tests Map.putIfAbsent(K, V).
MapPutTester<K,V>	A generic JUnit test which tests put operations on a map.
MapRemoveEntryTester<K,V>	Tester for Map.remove(Object, Object).
MapRemoveTester<K,V>	A generic JUnit test which tests remove operations on a map.
MapReplaceAllTester<K,V>	A generic JUnit test which tests replaceAll() operations on a map.
MapReplaceEntryTester<K,V>	A generic JUnit test which tests Map.replace(Object, Object, Object).
MapReplaceTester<K,V>	A generic JUnit test which tests Map.replace(Object, Object).
MapRetrievalCache<K,V>	A MapIteratorCache that adds additional caching.
MapRetrievalCache.CacheEntry<K,V>
Maps	Static utility methods pertaining to Map instances (including instances of SortedMap, BiMap, etc.).
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.EntryFunction
Maps.EntrySet<K,V>
Maps.EntryTransformer<K,V1,V2>	A transformation of the value of a key-value pair, using both key and value as inputs.
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.
MapSerializationTester<K,V>	Basic serialization test for maps.
MapSizeTester<K,V>	A generic JUnit test which tests size() operations on a map.
MapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a Map implementation.
MapTestSuiteBuilder.ReserializedMapGenerator<K,V>
MapToStringTester<K,V>	A generic JUnit test which tests toString() operations on a map.
MathPreconditions	A collection of preconditions for math functions.
MediaType	Represents an Internet Media Type (also known as a MIME Type or Content Type).
MediaType.Tokenizer
MessageDigestHashFunction	HashFunction adapter for MessageDigest instances.
MessageDigestHashFunction.MessageDigestHasher	Hasher that updates a message digest.
MessageDigestHashFunction.SerializedForm
MinimalCollection<E>	A simplistic collection which implements only the bare minimum allowed by the spec, and throws exceptions whenever it can.
MinimalIterable<E>	An implementation of Iterable which throws an exception on all invocations of the MinimalIterable.iterator() method after the first, and whose iterator is always unmodifiable.
MinimalSet<E>	A simplistic set which implements the bare minimum so that it can be used in tests without relying on any specific Set implementations.
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>
MockFutureListener	A simple mock implementation of Runnable that can be used for testing ListenableFutures.
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.
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.
MoreExecutors	Factory and utility methods for Executor, ExecutorService, and ThreadFactory.
MoreExecutors.Application	Represents the current application to register shutdown hooks.
MoreExecutors.DirectExecutorService
MoreExecutors.ListeningDecorator
MoreExecutors.ScheduledListeningDecorator
MoreExecutors.ScheduledListeningDecorator.ListenableScheduledTask<V>
MoreExecutors.ScheduledListeningDecorator.NeverSuccessfulListenableFutureTask
MoreFiles	Static utilities for use with Path instances, intended to complement Files.
MoreFiles.PathByteSink
MoreFiles.PathByteSource
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).
MoreObjects.ToStringHelper.ValueHolder
MultiEdgesConnecting<E>	A class to represent the set of edges connecting an (implicit) origin node to a target node.
MultiInputStream	An InputStream that concatenates multiple substreams.
Multimap<K,V>	A collection that maps keys to values, similar to Map, but in which each key may be associated with multiple values.
MultimapAsMapGetTester<K,V>	Tests for Multimap.asMap().get(Object).
MultimapAsMapTester<K,V>	Tests for Multimap.asMap().
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.LinkedListSupplier
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>
MultimapClearTester<K,V>	Tests for Multimap.clear().
MultimapContainsEntryTester<K,V>	Tester for Multimap.containsEntry(java.lang.Object, java.lang.Object).
MultimapContainsKeyTester<K,V>	Tester for the containsKey methods of Multimap and its asMap() view.
MultimapContainsValueTester<K,V>	Tester for Multimap.containsValue(java.lang.Object).
MultimapEntriesTester<K,V>	Tester for Multimap.entries.
MultimapEqualsTester<K,V>	Tester for Multimap.equals.
MultimapFeature	Optional features of classes derived from Multimap.
MultimapFeature.Require
MultimapForEachTester<K,V>	Tests for Multimap.forEach(java.util.function.BiConsumer<? super K, ? super V>).
MultimapGetTester<K,V>	Tests for Multimap.get(Object).
MultimapKeySetTester<K,V>	Tester for Multimap.keySet.
MultimapKeysTester<K,V>	Tester for Multimap.entries.
MultimapPutAllMultimapTester<K,V>	Tester for Multimap.putAll(Multimap).
MultimapPutIterableTester<K,V>	Tests for Multimap.putAll(Object, Iterable).
MultimapPutTester<K,V>	Tester for Multimap.put(K, V).
MultimapRemoveAllTester<K,V>	Tests for Multimap.removeAll(Object).
MultimapRemoveEntryTester<K,V>	Tests for Multimap.remove(Object, Object).
MultimapReplaceValuesTester<K,V>	Tests for Multimap.replaceValues(Object, Iterable).
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>
MultimapSizeTester<K,V>	Tester for the size methods of Multimap and its views.
MultimapTestSuiteBuilder<K,V,M extends Multimap<K,V>>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a Multimap implementation.
MultimapTestSuiteBuilder.AsMapGenerator<K,V,M extends Multimap<K,V>>
MultimapTestSuiteBuilder.EntriesGenerator<K,V,M extends Multimap<K,V>>
MultimapTestSuiteBuilder.KeysGenerator<K,V,M extends Multimap<K,V>>
MultimapTestSuiteBuilder.MultimapAsMapGetGenerator<K,V,M extends Multimap<K,V>>
MultimapTestSuiteBuilder.MultimapGetGenerator<K,V,M extends Multimap<K,V>>
MultimapTestSuiteBuilder.ReserializedMultimapGenerator<K,V,M extends Multimap<K,V>>
MultimapTestSuiteBuilder.ValuesGenerator<K,V,M extends Multimap<K,V>>
MultimapToStringTester<K,V>	Tester for Multimap.toString().
MultimapValuesTester<K,V>	Tester for Multimap.values.
MultiReader	A Reader that concatenates multiple readers.
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.
MultisetAddTester<E>	Tests for Multiset.add.
MultisetContainsTester<E>	Tests for Multiset.containsAll not already addressed by CollectionContainsTester.
MultisetCountTester<E>	Tests for Multiset#count.
MultisetElementSetTester<E>	Tests for Multiset.elementSet() not covered by the derived SetTestSuiteBuilder.
MultisetEntrySetTester<E>	Tests for Multiset.entrySet.
MultisetEqualsTester<E>	Tests for Multiset.equals and Multiset.hashCode.
MultisetFeature	Optional features of classes derived from Multiset.
MultisetFeature.Require
MultisetForEachEntryTester<E>	Tests for Multiset#forEachEntry.
MultisetIteratorTester<E>	Tester to make sure the iterator().remove() implementation of Multiset works when there are multiple occurrences of elements.
MultisetNavigationTester<E>	Tester for navigation of SortedMultisets.
MultisetNavigationTester.SubMultisetSpec
MultisetReadsTester<E>	A generic JUnit test which tests multiset-specific read operations.
MultisetRemoveTester<E>	Tests for Multiset#remove, Multiset.removeAll, and Multiset.retainAll not already covered by the corresponding Collection testers.
Multisets	Provides static utility methods for creating and working with Multiset instances.
Multisets.AbstractEntry<E>	Implementation of the equals, hashCode, and toString methods of Multiset.Entry.
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.
MultisetSerializationTester<E>	A generic JUnit test which tests multiset-specific serialization.
MultisetSetCountConditionallyTester<E>	A generic JUnit test which tests conditional setCount() operations on a multiset.
MultisetSetCountUnconditionallyTester<E>	A generic JUnit test which tests unconditional setCount() operations on a multiset.
MultisetTestSuiteBuilder<E>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a Multiset implementation.
MultisetTestSuiteBuilder.ElementSetGenerator<E>
MultisetTestSuiteBuilder.EntrySetGenerator<E>
MultisetTestSuiteBuilder.NoRecurse
MultisetTestSuiteBuilder.ReserializedMultisetGenerator<E>
Murmur3_128HashFunction	See MurmurHash3_x64_128 in the C++ implementation.
Murmur3_128HashFunction.Murmur3_128Hasher
Murmur3_32HashFunction	See MurmurHash3_x86_32 in the C++ implementation.
Murmur3_32HashFunction.Murmur3_32Hasher
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.
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.
MutableTypeToInstanceMap.UnmodifiableEntry<K,V>
MutableValueGraph<N,V>	A subinterface of ValueGraph which adds mutation methods.
NaturalOrdering	An ordering that uses the natural order of the values.
NavigableMapNavigationTester<K,V>	A generic JUnit test which tests operations on a NavigableMap.
NavigableMapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a NavigableMap implementation.
NavigableMapTestSuiteBuilder.DescendingTestMapGenerator<K,V>
NavigableMapTestSuiteBuilder.NavigableMapSubmapTestMapGenerator<K,V>
NavigableSetNavigationTester<E>	A generic JUnit test which tests operations on a NavigableSet.
NavigableSetTestSuiteBuilder<E>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a NavigableSet implementation.
NavigableSetTestSuiteBuilder.NavigableSetSubsetTestSetGenerator<E>
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.
NetworkConnections<N,E>	An interface for representing and manipulating an origin node's adjacent nodes and incident edges in a Network.
NullPointerTester	A test utility that verifies that your methods and constructors throw NullPointerException or UnsupportedOperationException whenever null is passed to a parameter whose declaration or type isn't annotated with an annotation with the simple name Nullable, , NullableType, or NullableDecl.
NullPointerTester.ExceptionTypePolicy	Strategy for exception type matching used by NullPointerTester.
NullPointerTester.Signature
NullPointerTester.Visibility	Visibility of any method or constructor.
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.
Objects	Helper functions that can operate on any Object.
OneSizeGenerator<T,E>	Generator for collection of a particular size.
OneSizeTestContainerGenerator<T,E>	The subject-generator interface accepted by Collection testers, for testing a Collection at one particular CollectionSize.
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.
Ordering.ArbitraryOrdering
Ordering.ArbitraryOrderingHolder
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.
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.
PairwiseEquivalence<T>
Parameter	Represents a method or constructor parameter.
ParseRequest	A string to be parsed as a number and the radix to interpret it in.
Partially	Outer class that exists solely to let us write Partially.GwtIncompatible instead of plain GwtIncompatible.
Partially.GwtIncompatible	The presence of this annotation on an API indicates that the method may be used with the Google Web Toolkit (GWT) but that it has some restrictions.
PatternCompiler	Pluggable interface for compiling a regex pattern.
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.
PerCollectionSizeTestSuiteBuilder<B extends PerCollectionSizeTestSuiteBuilder<B,G,T,E>,G extends TestContainerGenerator<T,E>,T,E>	This builder creates a composite test suite, containing a separate test suite for each CollectionSize present in the features specified by FeatureSpecificTestSuiteBuilder.withFeatures(Feature...).
PerCollectionSizeTestSuiteBuilder.OneSizeTestSuiteBuilder<T,E>	Builds a test suite for one particular CollectionSize.
Platform	Methods factored out so that they can be emulated differently in GWT.
Platform	Methods factored out so that they can be emulated differently in GWT.
Platform	Methods factored out so that they can be emulated differently in GWT.
Platform	This class is emulated in GWT.
Platform	Methods factored out so that they can be emulated differently in GWT.
Platform	Methods factored out so that they can be emulated differently in GWT.
Platform	Methods factored out so that they can be emulated differently in GWT.
Platform	Methods factored out so that they can be emulated differently in GWT.
Platform.JdkPatternCompiler
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.
Predicates.AndPredicate<T>
Predicates.CompositionPredicate<A,B>
Predicates.ContainsPatternFromStringPredicate
Predicates.ContainsPatternPredicate
Predicates.InPredicate<T>
Predicates.InstanceOfPredicate
Predicates.IsEqualToPredicate<T>
Predicates.NotPredicate<T>
Predicates.ObjectPredicate
Predicates.OrPredicate<T>
Predicates.SubtypeOfPredicate
Present<T>	Implementation of an Optional containing a reference.
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.
PublicSuffixPatterns	Do not use this class directly.
PublicSuffixType	Do not use this class directly.
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.
QueueElementTester<E>	A generic JUnit test which tests element() operations on a queue.
QueueOfferTester<E>	A generic JUnit test which tests offer operations on a queue.
QueuePeekTester<E>	A generic JUnit test which tests peek() operations on a queue.
QueuePollTester<E>	A generic JUnit test which tests poll() operations on a queue.
QueueRemoveTester<E>	A generic JUnit test which tests remove() operations on a queue.
Queues	Static utility methods pertaining to Queue and Deque instances.
QueueTestSuiteBuilder<E>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a queue implementation.
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.
RangeMap<K extends java.lang.Comparable,V>	A mapping from disjoint nonempty ranges to non-null values.
RangeSet<C extends java.lang.Comparable>	A set comprising zero or more nonempty, disconnected ranges of type C.
RateLimiter	A rate limiter.
RateLimiter.SleepingStopwatch
ReaderInputStream	An InputStream that converts characters from a Reader into bytes using an arbitrary Charset.
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...)).
ReferenceEntry<K,V>	An entry in a reference map.
Reflection	Static utilities relating to Java reflection.
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.
RelationshipTester<T>	Implementation helper for EqualsTester and EquivalenceTester that tests for equivalence classes.
RelationshipTester.Item<T>
RelationshipTester.ItemReporter
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.
ReserializingTestCollectionGenerator<E>	Reserializes the sets created by another test set generator.
ReserializingTestSetGenerator<E>	Reserializes the sets created by another test set generator.
Resources	Provides utility methods for working with resources in the classpath.
Resources.UrlByteSource	A byte source that reads from a URL using URL.openStream().
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.
RowSortedTable<R,C,V>	Interface that extends Table and whose rows are sorted.
Runnables	Static utility methods pertaining to the Runnable interface.
SafeTreeMap<K,V>	A wrapper around TreeMap that aggressively checks to see if keys are mutually comparable.
SafeTreeSet<E>	A wrapper around TreeSet that aggressively checks to see if elements are mutually comparable.
SameThreadScheduledExecutorService	A ScheduledExecutorService that executes all scheduled actions immediately in the calling thread.
SameThreadScheduledExecutorService.ImmediateScheduledFuture<V>
SampleElements<E>	A container class for the five sample elements we need for testing.
SampleElements.Chars
SampleElements.Collider
SampleElements.Colliders
SampleElements.Enums
SampleElements.Ints
SampleElements.Strings
SampleElements.Unhashables
SequentialExecutor	Executor ensuring that all Runnables submitted are executed in order, using the provided Executor, and sequentially such that no two will ever be running at the same time.
SequentialExecutor.WorkerRunningState
SerializableTester	Tests serialization and deserialization of an object, optionally asserting that the resulting object is equal to the original.
Serialization	Provides static methods for serializing collection classes.
Serialization.FieldSetter<T>
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.EmptyServiceManagerWarning	This is never thrown but only used for logging.
ServiceManager.FailedService
ServiceManager.Listener	A listener for the aggregate state changes of the services that are under management.
ServiceManager.NoOpService	A Service instance that does nothing.
ServiceManager.ServiceListener	A Service that wraps another service and times how long it takes for it to start and also calls the ServiceManager.ServiceManagerState.transitionService(Service, State, State), to record the state transitions.
ServiceManager.ServiceManagerState	An encapsulation of all the mutable state of the ServiceManager that needs to be accessed by instances of ServiceManager.ServiceListener.
ServiceManagerBridge	Superinterface of ServiceManager to introduce a bridge method for servicesByState(), to ensure binary compatibility with older Guava versions that specified servicesByState() to return ImmutableMultimap.
SetAddAllTester<E>	A generic JUnit test which tests addAll operations on a set.
SetAddTester<E>	A generic JUnit test which tests add operations on a set.
SetCreationTester<E>	A generic JUnit test which tests creation (typically through a constructor or static factory method) of a set.
SetEqualsTester<E>	Tests Set.equals(java.lang.Object).
SetFeature	Optional features of classes derived from Set.
SetFeature.Require
SetGenerators	Generators of different types of sets and derived collections from sets.
SetGenerators.AbstractContiguousSetGenerator
SetGenerators.ContiguousSetDescendingGenerator
SetGenerators.ContiguousSetGenerator
SetGenerators.ContiguousSetHeadsetGenerator
SetGenerators.ContiguousSetSubsetGenerator
SetGenerators.ContiguousSetTailsetGenerator
SetGenerators.DegeneratedImmutableSetGenerator
SetGenerators.ImmutableSetAsListGenerator
SetGenerators.ImmutableSetCopyOfGenerator
SetGenerators.ImmutableSetSizedBuilderGenerator
SetGenerators.ImmutableSetTooBigBuilderGenerator
SetGenerators.ImmutableSetTooSmallBuilderGenerator
SetGenerators.ImmutableSetUnsizedBuilderGenerator
SetGenerators.ImmutableSetWithBadHashesGenerator
SetGenerators.ImmutableSortedSetAsListGenerator
SetGenerators.ImmutableSortedSetAsListSubListGenerator
SetGenerators.ImmutableSortedSetCopyOfGenerator
SetGenerators.ImmutableSortedSetDescendingAsListGenerator
SetGenerators.ImmutableSortedSetDescendingGenerator
SetGenerators.ImmutableSortedSetExplicitComparator
SetGenerators.ImmutableSortedSetExplicitSuperclassComparatorGenerator
SetGenerators.ImmutableSortedSetHeadsetGenerator
SetGenerators.ImmutableSortedSetReversedOrderGenerator
SetGenerators.ImmutableSortedSetSubsetAsListGenerator
SetGenerators.ImmutableSortedSetSubsetAsListSubListGenerator
SetGenerators.ImmutableSortedSetSubsetGenerator
SetGenerators.ImmutableSortedSetTailsetGenerator
SetGenerators.ImmutableSortedSetUnhashableGenerator
SetGenerators.TestUnhashableSetGenerator
SetHashCodeTester<E>	Tests Set.hashCode().
SetMultimap<K,V>	A Multimap that cannot hold duplicate key-value pairs.
SetMultimapAsMapTester<K,V>	Testers for SetMultimap.asMap().
SetMultimapEqualsTester<K,V>	Testers for SetMultimap.equals(Object).
SetMultimapPutAllTester<K,V>	Tests for SetMultimap.replaceValues(K, java.lang.Iterable<? extends V>).
SetMultimapPutTester<K,V>	Tests for SetMultimap.replaceValues(K, java.lang.Iterable<? extends V>).
SetMultimapReplaceValuesTester<K,V>	Tests for SetMultimap.replaceValues(K, java.lang.Iterable<? extends V>).
SetMultimapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a SetMultimap implementation.
SetMultimapTestSuiteBuilder.EntriesGenerator<K,V>
SetMultimapTestSuiteBuilder.MultimapAsMapGetGenerator<K,V>
SetMultimapTestSuiteBuilder.MultimapGetGenerator<K,V>
SetRemoveTester<E>	A generic JUnit test which tests remove operations on a set.
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>
SettableFuture<V>	A ListenableFuture whose result can be set by a SettableFuture.set(Object), SettableFuture.setException(Throwable) or SettableFuture.setFuture(ListenableFuture) call.
SetTestSuiteBuilder<E>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a Set implementation.
SetTestSuiteBuilder.ReserializedSetGenerator<E>
Shorts	Static utility methods pertaining to short primitives, that are not already found in either Short or Arrays.
Shorts.LexicographicalComparator
Shorts.ShortArrayAsList
Shorts.ShortConverter
ShortsMethodsForWeb	Holder for web specializations of methods of Shorts.
SignedBytes	Static utility methods pertaining to byte primitives that interpret values as signed.
SignedBytes.LexicographicalComparator
SimpleTimeLimiter	A TimeLimiter that runs method calls in the background using an ExecutorService.
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.
SipHashFunction	HashFunction implementation of SipHash-c-d.
SipHashFunction.SipHasher
SloppyTearDown	Simple utility for when you want to create a TearDown that may throw an exception but should not fail a test when it does.
SmallCharMatcher	An immutable version of CharMatcher for smallish sets of characters that uses a hash table with linear probing to check for matches.
SmoothRateLimiter
SmoothRateLimiter.SmoothBursty	This implements a "bursty" RateLimiter, where storedPermits are translated to zero throttling.
SmoothRateLimiter.SmoothWarmingUp	This implements the following function where coldInterval = coldFactor * stableInterval.
SortedIterable<T>	An Iterable whose elements are sorted relative to a Comparator, typically provided at creation time.
SortedIterables	Utilities for dealing with sorted collections of all types.
SortedLists	Static methods pertaining to sorted List instances.
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.
SortedMapDifference<K,V>	An object representing the differences between two sorted maps.
SortedMapGenerators	Generators of sorted maps and derived collections.
SortedMapGenerators.ImmutableSortedMapCopyOfEntriesGenerator
SortedMapGenerators.ImmutableSortedMapEntryListGenerator
SortedMapGenerators.ImmutableSortedMapGenerator
SortedMapGenerators.ImmutableSortedMapKeyListGenerator
SortedMapGenerators.ImmutableSortedMapValueListGenerator
SortedMapInterfaceTest<K,V>	Tests representing the contract of SortedMap.
SortedMapNavigationTester<K,V>	A generic JUnit test which tests operations on a SortedMap.
SortedMapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a SortedMap implementation.
SortedMapTestSuiteBuilder.NoRecurse	To avoid infinite recursion, test suites with these marker features won't have derived suites created for them.
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.
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().
SortedMultisetTestSuiteBuilder<E>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a SortedMultiset implementation.
SortedMultisetTestSuiteBuilder.Bound	Two bounds (from and to) define how to build a subMultiset.
SortedMultisetTestSuiteBuilder.ForwardingTestMultisetGenerator<E>
SortedMultisetTestSuiteBuilder.NoRecurse	To avoid infinite recursion, test suites with these marker features won't have derived suites created for them.
SortedSetMultimap<K,V>	A SetMultimap whose set of values for a given key are kept sorted; that is, they comprise a SortedSet.
SortedSetMultimapAsMapTester<K,V>	Testers for SortedSetMultimap.asMap().
SortedSetMultimapGetTester<K,V>	Tester for SortedSetMultimap.get(Object).
SortedSetMultimapTestSuiteBuilder<K,V>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a SortedSetMultimap implementation.
SortedSetNavigationTester<E>	A generic JUnit test which tests operations on a SortedSet.
SortedSetTestSuiteBuilder<E>	Creates, based on your criteria, a JUnit test suite that exhaustively tests a SortedSet implementation.
SparseImmutableTable<R,C,V>	A RegularImmutableTable optimized for sparse data.
SpliteratorTester<E>	Tester for Spliterator implementations.
SpliteratorTester.GeneralSpliterator<E>
SpliteratorTester.GeneralSpliteratorOfObject<E>
SpliteratorTester.GeneralSpliteratorOfPrimitive<E,C>
SpliteratorTester.Ordered	Return type from "contains the following elements" assertions.
SpliteratorTester.SpliteratorDecompositionStrategy	Different ways of decomposing a Spliterator, all of which must produce the same elements (up to ordering, if Spliterator.ORDERED is not present).
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.
Splitter.SplittingIterator
Splitter.Strategy
StandardMutableGraph<N>	Standard implementation of MutableGraph that supports both directed and undirected graphs.
StandardMutableNetwork<N,E>	Standard implementation of MutableNetwork that supports both directed and undirected graphs.
StandardMutableValueGraph<N,V>	Standard implementation of MutableValueGraph that supports both directed and undirected graphs.
StandardNetwork<N,E>	Standard implementation of Network that supports the options supplied by NetworkBuilder.
StandardRowSortedTable<R,C,V>	Implementation of Table whose iteration ordering across row keys is sorted by their natural ordering or by a supplied comparator.
StandardSystemProperty	Represents a standard system property.
StandardTable<R,C,V>	Table implementation backed by a map that associates row keys with column key / value secondary maps.
StandardValueGraph<N,V>	Standard implementation of ValueGraph that supports the options supplied by AbstractGraphBuilder.
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.
Streams.MapWithIndexSpliterator<F extends java.util.Spliterator<?>,R,S extends Streams.MapWithIndexSpliterator<F,R,S>>
Streams.TemporaryPair<A,B>
Strings	Static utility methods pertaining to String or CharSequence instances.
Striped<L>	A striped Lock/Semaphore/ReadWriteLock.
Striped.CompactStriped<L>	Implementation of Striped where 2^k stripes are represented as an array of the same length, eagerly initialized.
Striped.LargeLazyStriped<L>	Implementation of Striped where up to 2^k stripes can be represented, using a ConcurrentMap where the key domain is [0..2^k).
Striped.PaddedLock
Striped.PaddedSemaphore
Striped.PowerOfTwoStriped<L>
Striped.SmallLazyStriped<L>	Implementation of Striped where up to 2^k stripes can be represented, using an AtomicReferenceArray of size 2^k.
Striped.SmallLazyStriped.ArrayReference<L>
Striped.WeakSafeCondition	Condition object that ensures a strong reference is retained to a specified object.
Striped.WeakSafeLock	Lock object that ensures a strong reference is retained to a specified object.
Striped.WeakSafeReadWriteLock	ReadWriteLock implementation whose read and write locks retain a reference back to this lock.
Striped64	A package-local class holding common representation and mechanics for classes supporting dynamic striping on 64bit values.
Striped64	A package-local class holding common representation and mechanics for classes supporting dynamic striping on 64bit values.
Striped64.Cell	Padded variant of AtomicLong supporting only raw accesses plus CAS.
Striped64.Cell	Padded variant of AtomicLong supporting only raw accesses plus CAS.
Subscribe	Marks a method as an event subscriber.
Subscriber	A subscriber method on a specific object, plus the executor that should be used for dispatching events to it.
Subscriber.SynchronizedSubscriber	Subscriber that synchronizes invocations of a method to ensure that only one thread may enter the method at a time.
SubscriberExceptionContext	Context for an exception thrown by a subscriber.
SubscriberExceptionHandler	Handler for exceptions thrown by event subscribers.
SubscriberRegistry	Registry of subscribers to a single event bus.
SubscriberRegistry.MethodIdentifier
SuccessorsFunction<N>	A functional interface for graph-structured data.
Supplier<T>	Legacy version of java.util.function.Supplier.
Suppliers	Useful suppliers.
Suppliers.ExpiringMemoizingSupplier<T>
Suppliers.MemoizingSupplier<T>
Suppliers.NonSerializableMemoizingSupplier<T>
Suppliers.SupplierComposition<F,T>
Suppliers.SupplierFunction<T>
Suppliers.SupplierFunctionImpl
Suppliers.SupplierOfInstance<T>
Suppliers.ThreadSafeSupplier<T>
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>
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.
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>
TearDown	An object that can perform a TearDown.tearDown() operation.
TearDownAccepter	Any object which can accept registrations of TearDown instances.
TearDownStack	A TearDownStack contains a stack of TearDown instances.
TestBiMapGenerator<K,V>	Creates bimaps, containing sample entries, to be tested.
TestCharacterListGenerator	Generates List<Character> instances for test suites.
TestCollectionGenerator<E>	Creates collections, containing sample elements, to be tested.
TestCollidingSetGenerator	A generator using sample elements whose hash codes all collide badly.
TestContainerGenerator<T,E>	To be implemented by test generators of things that can contain elements.
TestEnumMapGenerator	Implementation helper for TestMapGenerator for use with enum maps.
TestEnumMultisetGenerator	An abstract TestMultisetGenerator for generating multisets containing enum values.
TestEnumSetGenerator	An abstract TestSetGenerator for generating sets containing enum values.
TesterAnnotation	Use this to meta-annotate XxxFeature.Require annotations, so that those annotations can be used to decide whether to apply a test to a given class-under-test.
TesterRequirements	Encapsulates the constraints that a class under test must satisfy in order for a tester method to be run against that class.
TestingExecutors	Factory methods for ExecutorService for testing.
TestingExecutors.NoOpScheduledExecutorService
TestingExecutors.NoOpScheduledExecutorService.NeverScheduledFuture<V>
TestIntegerSetGenerator	Create integer sets for collection tests.
TestIntegerSortedSetGenerator	Create integer sets for testing collections that are sorted by natural ordering.
TestIteratorGenerator<E>	Creates iterators to be tested.
TestListGenerator<E>	Creates sets, containing sample elements, to be tested.
TestListMultimapGenerator<K,V>	A generator for ListMultimap implementations based on test data.
TestLogHandler	Tests may use this to intercept messages that are logged by the code under test.
TestMapEntrySetGenerator<K,V>	Creates map entries using sample keys and sample values.
TestMapGenerator<K,V>	Creates maps, containing sample elements, to be tested.
TestMultimapGenerator<K,V,M extends Multimap<K,V>>	Creates multimaps, containing sample elements, to be tested.
TestMultisetGenerator<E>	Creates multisets, containing sample elements, to be tested.
TestQueueGenerator<E>	Creates queues, containing sample elements, to be tested.
TestSetGenerator<E>	Creates sets, containing sample elements, to be tested.
TestSetMultimapGenerator<K,V>	A generator for SetMultimap implementations based on test data.
TestsForListsInJavaUtil	Generates a test suite covering the List implementations in the java.util package.
TestsForMapsInJavaUtil	Generates a test suite covering the Map implementations in the java.util package.
TestsForMapsInJavaUtil.NullFriendlyComparator<T>
TestsForQueuesInJavaUtil	Generates a test suite covering the Queue implementations in the java.util package.
TestsForSetsInJavaUtil	Generates a test suite covering the Set implementations in the java.util package.
TestsForSetsInJavaUtil.NullFriendlyComparator<T>
TestSortedMapGenerator<K,V>	Creates sorted maps, containing sample elements, to be tested.
TestSortedSetGenerator<E>	Creates sorted sets, containing sample elements, to be tested.
TestStringBiMapGenerator	Implementation helper for TestBiMapGenerator for use with bimaps of strings.
TestStringCollectionGenerator	String creation for testing arbitrary collections.
TestStringListGenerator	TODO: javadoc.
TestStringListMultimapGenerator	A skeleton generator for a ListMultimap implementation.
TestStringMapGenerator	Implementation helper for TestMapGenerator for use with maps of strings.
TestStringMultisetGenerator	Create multisets of strings for tests.
TestStringQueueGenerator	Create queue of strings for tests.
TestStringSetGenerator	Create string sets for collection tests.
TestStringSetMultimapGenerator	A skeleton generator for a SetMultimap implementation.
TestStringSortedMapGenerator	Implementation helper for TestMapGenerator for use with sorted maps of strings.
TestStringSortedSetGenerator	Create string sets for testing collections that are sorted by natural ordering.
TestSubjectGenerator<T>	To be implemented by test generators that can produce test subjects without requiring any parameters.
TestUnhashableCollectionGenerator<T extends java.util.Collection<UnhashableObject>>	Creates collections containing unhashable sample elements, to be tested.
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.
TimeoutFuture<V>	Implementation of Futures#withTimeout.
TimeoutFuture.Fire<V>	A runnable that is called when the delegate or the timer completes.
TimeoutFuture.TimeoutFutureException
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.
Traverser<N>	An object that can traverse the nodes that are reachable from a specified (set of) start node(s) using a specified SuccessorsFunction.
Traverser.GraphTraverser<N>
Traverser.Order
Traverser.TreeTraverser<N>
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.Aggregate	A function which can be summed across a subtree.
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>
TrieParser	Parser for a map of reversed domain names stored as a serialized radix tree.
TrustedListenableFutureTask<V>	A RunnableFuture that also implements the ListenableFuture interface.
TypeCapture<T>	Captures the actual type of T.
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.
TypeResolver.TypeMappingIntrospector
TypeResolver.TypeTable	A TypeTable maintains mapping from TypeVariable to types.
TypeResolver.TypeVariableKey	Wraps around TypeVariable<?> to ensure that any two type variables are equal as long as they are declared by the same GenericDeclaration and have the same name, even if their bounds differ.
TypeResolver.WildcardCapturer
Types	Utilities for working with Type.
Types.ClassOwnership	Decides what owner type to use for constructing ParameterizedType from a raw class.
Types.GenericArrayTypeImpl
Types.JavaVersion
Types.NativeTypeVariableEquals<X>	Per issue 1635, In JDK 1.7.0_51-b13, Types.TypeVariableImpl.equals(Object) is changed to no longer be equal to custom TypeVariable implementations.
Types.ParameterizedTypeImpl
Types.TypeVariableImpl<D extends java.lang.reflect.GenericDeclaration>
Types.TypeVariableInvocationHandler	Invocation handler to work around a compatibility problem between Java 7 and Java 8.
Types.WildcardTypeImpl
TypeToInstanceMap<B>	A map, each entry of which maps a TypeToken to an instance of that type.
TypeToken<T>	A Type with generics.
TypeToken.Bounds
TypeToken.SimpleTypeToken<T>
TypeToken.TypeCollector<K>	Collects parent types from a sub type.
TypeToken.TypeCollector.ForwardingTypeCollector<K>
TypeToken.TypeFilter
TypeVisitor	Based on what a Type is, dispatch it to the corresponding visit* method.
UncaughtExceptionHandlers	Factories for Thread.UncaughtExceptionHandler instances.
UncaughtExceptionHandlers.Exiter
UncheckedExecutionException	Unchecked variant of ExecutionException.
UncheckedTimeoutException	Unchecked version of TimeoutException.
UndirectedGraphConnections<N,V>	An implementation of GraphConnections for undirected graphs.
UndirectedMultiNetworkConnections<N,E>	An implementation of NetworkConnections for undirected networks with parallel edges.
UndirectedNetworkConnections<N,E>	An implementation of NetworkConnections for undirected networks.
UnhashableObject	An unhashable object to be used in testing as values in our collections.
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.
UnmodifiableCollectionTests	A series of tests that support asserting that collections cannot be modified, either through direct or indirect means.
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).
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).
UnsignedBytes.LexicographicalComparatorHolder	Provides a lexicographical comparator implementation; either a Java implementation or a faster implementation based on Unsafe.
UnsignedBytes.LexicographicalComparatorHolder.PureJavaComparator
UnsignedBytes.LexicographicalComparatorHolder.UnsafeComparator
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).
UnsignedInts.LexicographicalComparator
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).
UnsignedLongs.LexicographicalComparator
UnsignedLongs.ParseOverflowDetection
UrlEscapers	Escaper instances suitable for strings to be included in particular sections of URLs.
UsingToStringOrdering	An ordering that uses the natural order of the string representation of the values.
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.
Weigher<K,V>	Calculates the weights of cache entries.
WrappingExecutorService	An abstract ExecutorService that allows subclasses to wrap tasks before they are submitted to the underlying executor.
WrappingScheduledExecutorService	An abstract ScheduledExecutorService that allows subclasses to wrap tasks before they are submitted to the underlying executor.
WrongType	A type which will never be used as the element type of any collection in our tests, and so can be used to test how a Collection behaves when given input of the wrong type.
XmlEscapers	Escaper instances suitable for strings to be included in XML attribute values and elements' text contents.