Package | Description |
---|---|
com.google.common.annotations |
Common annotation types.
|
com.google.common.base |
Basic utility libraries and interfaces.
|
com.google.common.collect |
This package contains generic collection interfaces and implementations, and
other utilities for working with collections.
|
com.google.common.net |
This package contains utility methods and classes for working with net
addresses (numeric IP and domain names).
|
com.google.common.primitives |
Static utilities for working with the eight primitive types and
void . |
Modifier and Type | Class and Description |
---|---|
interface |
Beta
Signifies that a public API (public class, method or field) is subject to
incompatible changes, or even removal, in a future release.
|
interface |
GwtCompatible
The presence of this annotation on a type indicates that the type may be
used with the
Google Web Toolkit (GWT).
|
interface |
GwtIncompatible
The presence of this annotation on a method indicates that the method may
not be used with the
Google Web Toolkit (GWT),
even though its type is annotated as
GwtCompatible and accessible in
GWT. |
interface |
VisibleForTesting
An annotation that indicates that the visibility of a type or member has
been relaxed to make the code testable.
|
Modifier and Type | Class and Description |
---|---|
class |
Ascii
Static methods pertaining to ASCII characters (those in the range of values
0x00 through 0x7F ), and to strings containing such
characters. |
class |
CaseFormat
Utility class for converting between various ASCII case formats.
|
class |
CharMatcher
|
class |
Enums
Utility methods for working with
Enum instances. |
interface |
Equivalence<T>
A strategy for determining whether two instances are considered equivalent.
|
class |
Equivalences
Contains static factory methods for creating
Equivalence instances. |
interface |
Function<F,T>
Determines an output value based on an input value.
|
class |
Functions
Static utility methods pertaining to
Function instances. |
class |
Joiner
|
class |
Objects
Helper functions that can operate on any
Object . |
class |
Preconditions
Simple static methods to be called at the start of your own methods to verify
correct arguments and state.
|
interface |
Predicate<T>
Determines a true or false value for a given input.
|
class |
Predicates
Static utility methods pertaining to
Predicate instances. |
class |
Splitter
An object that divides strings (or other instances of
CharSequence )
into substrings, by recognizing a separator (a.k.a. |
class |
Strings
Static utility methods pertaining to
String or CharSequence
instances. |
interface |
Supplier<T>
A class that can supply objects of a single type.
|
class |
Suppliers
Useful suppliers.
|
Modifier and Type | Method and Description |
---|---|
static <T> Predicate<T> |
Predicates.alwaysFalse()
Returns a predicate that always evaluates to
false . |
static <T> Predicate<T> |
Predicates.alwaysTrue()
Returns a predicate that always evaluates to
true . |
static <T> Predicate<T> |
Predicates.isNull()
Returns a predicate that evaluates to
true if the object reference
being tested is null. |
static <T> Predicate<T> |
Predicates.notNull()
Returns a predicate that evaluates to
true if the object reference
being tested is not null. |
static <T> Equivalence<Iterable<T>> |
Equivalences.pairwise(Equivalence<? super T> elementEquivalence)
Returns an equivalence over iterables based on the equivalence of their elements.
|
Modifier and Type | Class and Description |
---|---|
class |
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. |
class |
AbstractLinkedIterator<T>
This class provides a skeletal implementation of the
Iterator
interface for sequences whose next element can always be derived from the
previous element. |
class |
ArrayListMultimap<K,V>
Implementation of
Multimap that uses an ArrayList to store
the values for a given key. |
interface |
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.
|
interface |
ClassToInstanceMap<B>
A map, each entry of which maps a Java
raw type to an instance of that type.
|
class |
Collections2
Provides static methods for working with
Collection instances. |
class |
ComparisonChain
A utility for performing a "lazy" chained comparison statement, which
performs comparisons only until it finds a nonzero result.
|
class |
ComputationException
Wraps an exception that occurred during a computation.
|
interface |
Constraint<E>
A constraint that an element must satisfy in order to be added to a
collection.
|
class |
Constraints
Factories and utilities pertaining to the
Constraint interface. |
class |
EnumBiMap<K extends Enum<K>,V extends Enum<V>>
A
BiMap backed by two EnumMap instances. |
class |
EnumHashBiMap<K extends Enum<K>,V>
A
BiMap backed by an EnumMap instance for keys-to-values, and
a HashMap instance for values-to-keys. |
class |
EnumMultiset<E extends Enum<E>>
Multiset implementation backed by an
EnumMap . |
class |
ForwardingCollection<E>
A collection which forwards all its method calls to another collection.
|
class |
ForwardingConcurrentMap<K,V>
A concurrent map which forwards all its method calls to another concurrent
map.
|
class |
ForwardingIterator<T>
An iterator which forwards all its method calls to another iterator.
|
class |
ForwardingList<E>
A list which forwards all its method calls to another list.
|
class |
ForwardingListIterator<E>
A list iterator which forwards all its method calls to another list
iterator.
|
class |
ForwardingListMultimap<K,V>
A list multimap which forwards all its method calls to another list multimap.
|
class |
ForwardingMap<K,V>
A map which forwards all its method calls to another map.
|
class |
ForwardingMapEntry<K,V>
A map entry which forwards all its method calls to another map entry.
|
class |
ForwardingMultimap<K,V>
A multimap which forwards all its method calls to another multimap.
|
class |
ForwardingMultiset<E>
A multiset which forwards all its method calls to another multiset.
|
class |
ForwardingObject
An abstract base class for implementing the decorator pattern.
|
class |
ForwardingQueue<E>
A queue which forwards all its method calls to another queue.
|
class |
ForwardingSet<E>
A set which forwards all its method calls to another set.
|
class |
ForwardingSetMultimap<K,V>
A set multimap which forwards all its method calls to another set multimap.
|
class |
ForwardingSortedMap<K,V>
A sorted map which forwards all its method calls to another sorted map.
|
class |
ForwardingSortedSet<E>
A sorted set which forwards all its method calls to another sorted set.
|
class |
ForwardingSortedSetMultimap<K,V>
A sorted set multimap which forwards all its method calls to another sorted
set multimap.
|
class |
ForwardingTable<R,C,V>
A table which forwards all its method calls to another table.
|
class |
GenericMapMaker<K0,V0>
A class exactly like
MapMaker , except restricted in the types of maps
it can build. |
class |
HashBasedTable<R,C,V>
Implementation of
Table using hash tables. |
class |
HashBiMap<K,V>
|
class |
HashMultimap<K,V>
Implementation of
Multimap using hash tables. |
class |
HashMultiset<E>
Multiset implementation backed by a
HashMap . |
class |
ImmutableBiMap<K,V>
An immutable
BiMap with reliable user-specified iteration order. |
class |
ImmutableCollection<E>
An immutable collection.
|
class |
ImmutableList<E>
A high-performance, immutable, random-access
List implementation. |
class |
ImmutableListMultimap<K,V>
An immutable
ListMultimap with reliable user-specified key and value
iteration order. |
class |
ImmutableMap<K,V>
An immutable, hash-based
Map with reliable user-specified iteration
order. |
class |
ImmutableMultimap<K,V>
An immutable
Multimap . |
class |
ImmutableMultiset<E>
An immutable hash-based multiset.
|
class |
ImmutableSet<E>
A high-performance, immutable
Set with reliable, user-specified
iteration order. |
class |
ImmutableSetMultimap<K,V>
An immutable
SetMultimap with reliable user-specified key and value
iteration order. |
class |
ImmutableSortedMap<K,V>
An immutable
SortedMap . |
class |
ImmutableSortedSet<E>
An immutable
SortedSet that stores its elements in a sorted array. |
class |
Iterables
This class contains static utility methods that operate on or return objects
of type
Iterable . |
class |
Iterators
This class contains static utility methods that operate on or return objects
of type
Iterator . |
class |
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. |
class |
LinkedHashMultiset<E>
A
Multiset implementation with predictable iteration order. |
class |
LinkedListMultimap<K,V>
An implementation of
ListMultimap that supports deterministic
iteration order for both keys and values. |
interface |
ListMultimap<K,V>
A
Multimap that can hold duplicate key-value pairs and that maintains
the insertion ordering of values for a given key. |
class |
Lists
Static utility methods pertaining to
List instances. |
interface |
MapConstraint<K,V>
A constraint on the keys and values that may be added to a
Map or
Multimap . |
class |
MapConstraints
Factory and utilities pertaining to the
MapConstraint interface. |
interface |
MapDifference<K,V>
An object representing the differences between two maps.
|
class |
MapMaker
A
ConcurrentMap builder, providing any combination of these
features: soft or weak keys, soft or weak values, size-based evicition, timed expiration, and
on-demand computation of values. |
class |
Maps
Static utility methods pertaining to
Map instances. |
interface |
Multimap<K,V>
A collection similar to a
Map , but which may associate multiple
values with a single key. |
class |
Multimaps
Provides static methods acting on or generating a
Multimap . |
interface |
Multiset<E>
A collection that supports order-independent equality, like
Set , but
may have duplicate elements. |
class |
Multisets
Provides static utility methods for creating and working with
Multiset instances. |
class |
ObjectArrays
Static utility methods pertaining to object arrays.
|
class |
Ordering<T>
A comparator with added methods to support common functions.
|
interface |
PeekingIterator<E>
An iterator that supports a one-element lookahead while iterating.
|
interface |
RowSortedTable<R,C,V>
Interface that extends
Table and whose rows are sorted. |
interface |
SetMultimap<K,V>
A
Multimap that cannot hold duplicate key-value pairs. |
class |
Sets
Static utility methods pertaining to
Set instances. |
interface |
SortedMapDifference<K,V>
An object representing the differences between two sorted maps.
|
class |
SortedMaps
Static utility methods pertaining to
SortedMap instances. |
interface |
SortedSetMultimap<K,V>
A
SetMultimap whose set of values for a given key are kept sorted;
that is, they comprise a SortedSet . |
interface |
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.
|
class |
Tables
Provides static methods that involve a
Table . |
class |
TreeBasedTable<R,C,V>
Implementation of
Table whose row keys and column keys are ordered
by their natural ordering or by supplied comparators. |
class |
TreeMultimap<K,V>
Implementation of
Multimap whose keys and values are ordered by
their natural ordering or by supplied comparators. |
class |
TreeMultiset<E>
A multiset which maintains the ordering of its elements, according to either
their natural order or an explicit
Comparator . |
class |
UnmodifiableIterator<E>
An iterator that does not support
UnmodifiableIterator.remove() . |
class |
UnmodifiableListIterator<E>
A list iterator that does not support
UnmodifiableIterator.remove() , UnmodifiableListIterator.add(E) , or
UnmodifiableListIterator.set(E) . |
Modifier and Type | Method and Description |
---|---|
<U extends T> |
Ordering.compound(Comparator<? super U> secondaryComparator)
Returns an ordering which first uses the ordering
this , but which
in the event of a "tie", then delegates to secondaryComparator . |
static <T> Ordering<T> |
Ordering.compound(Iterable<? extends Comparator<? super T>> comparators)
Returns an ordering which tries each given comparator in order until a
non-zero result is found, returning that result, and returning zero only if
all comparators return zero.
|
static <T> Ordering<T> |
Ordering.explicit(List<T> valuesInOrder)
Returns an ordering that compares objects according to the order in
which they appear in the given list.
|
static <T> Ordering<T> |
Ordering.explicit(T leastValue,
T... remainingValuesInOrder)
Returns an ordering that compares objects according to the order in
which they are given to this method.
|
static <T> Ordering<T> |
Ordering.from(Comparator<T> comparator)
Returns an ordering for a pre-existing
comparator . |
static <T> Ordering<T> |
Ordering.from(Ordering<T> ordering)
Deprecated.
no need to use this
|
static <K,V> Map.Entry<K,V> |
Maps.immutableEntry(K key,
V value)
Returns an immutable map entry with the specified key and value.
|
static <E extends Enum<E>> |
Sets.immutableEnumSet(E anElement,
E... otherElements)
Returns an immutable set instance containing the given enum elements.
|
static <E extends Enum<E>> |
Sets.immutableEnumSet(Iterable<E> elements)
Returns an immutable set instance containing the given enum elements.
|
<S extends T> |
Ordering.lexicographical()
Returns a new ordering which sorts iterables by comparing corresponding
elements pairwise until a nonzero result is found; imposes "dictionary
order".
|
static <C extends Comparable> |
Ordering.natural()
Returns a serializable ordering that uses the natural order of the values.
|
static <E> ArrayList<E> |
Lists.newArrayList()
Creates a mutable, empty
ArrayList instance. |
static <E> ArrayList<E> |
Lists.newArrayList(E... elements)
Creates a mutable
ArrayList instance containing the given
elements. |
static <E> ArrayList<E> |
Lists.newArrayList(Iterable<? extends E> elements)
Creates a mutable
ArrayList instance containing the given
elements. |
static <E> ArrayList<E> |
Lists.newArrayList(Iterator<? extends E> elements)
Creates a mutable
ArrayList instance containing the given
elements. |
static <E> ArrayList<E> |
Lists.newArrayListWithCapacity(int initialArraySize)
Creates an
ArrayList instance backed by an array of the
exact size specified; equivalent to
ArrayList.ArrayList(int) . |
static <E> ArrayList<E> |
Lists.newArrayListWithExpectedSize(int estimatedSize)
Creates an
ArrayList instance sized appropriately to hold an
estimated number of elements without resizing. |
static <E> LinkedList<E> |
Lists.newLinkedList()
Creates an empty
LinkedList instance. |
static <E> LinkedList<E> |
Lists.newLinkedList(Iterable<? extends E> elements)
Creates a
LinkedList instance containing the given elements. |
<S extends T> |
Ordering.nullsFirst()
Returns an ordering that treats
null as less than all other values
and uses this to compare non-null values. |
<S extends T> |
Ordering.nullsLast()
Returns an ordering that treats
null as greater than all other
values and uses this ordering to compare non-null values. |
<F> Ordering<F> |
Ordering.onResultOf(Function<F,? extends T> function)
Returns a new ordering on
F which orders elements by first applying
a function to them, then comparing those results using this . |
static <E> Set<Set<E>> |
Sets.powerSet(Set<E> set)
Returns the set of all possible subsets of
set . |
<S extends T> |
Ordering.reverse()
Returns the reverse of this ordering; the
Ordering equivalent to
Collections.reverseOrder(Comparator) . |
static Ordering<Object> |
Ordering.usingToString()
Returns an ordering that compares objects by the natural ordering of their
string representations as returned by
toString() . |
Modifier and Type | Class and Description |
---|---|
class |
InternetDomainName
An immutable well-formed internet domain name, such as
com or foo.co.uk . |
Modifier and Type | Class and Description |
---|---|
class |
Booleans
|
class |
Bytes
|
class |
Chars
|
class |
Doubles
|
class |
Floats
|
class |
Ints
|
class |
Longs
|
class |
Shorts
|
class |
SignedBytes
Static utility methods pertaining to
byte primitives that
interpret values as signed. |