Package com.google.common.collect

This package contains generic collection interfaces and implementations, and other utilities for working with collections.

See:
Description

Interface Summary

BiMap<K,V>	A bimap (or "bidirectional map") is a map that preserves the uniqueness of its values as well as that of its keys.
ClassToInstanceMap<B>	A map, each entry of which maps a Java raw type to an instance of that type.
Constraint<E>	A constraint that an element must satisfy in order to be added to a collection.
CustomConcurrentHashMap.ComputingStrategy<K,V,E>	Extends CustomConcurrentHashMap.Strategy to add support for computing values on-demand.
CustomConcurrentHashMap.Internals<K,V,E>	Provides access to a map's internal entries.
CustomConcurrentHashMap.Strategy<K,V,E>	Implements behavior specific to the client's concurrent hash map implementation.
ListMultimap<K,V>	A Multimap that can hold duplicate key-value pairs and that maintains the insertion ordering of values for a given key.
MapConstraint<K,V>	A constraint on the keys and values that may be added to a Map or Multimap.
Multimap<K,V>	A collection similar to a Map, but which may associate multiple values with a single key.
Multiset<E>	A collection that supports order-independent equality, like Set, but may have duplicate elements.
Multiset.Entry<E>	An unmodifiable element-count pair for a multiset.
PeekingIterator<E>	An iterator that supports a one-element lookahead while iterating.
SetMultimap<K,V>	A Multimap that cannot hold duplicate key-value pairs.
SortedSetMultimap<K,V>	A SetMultimap whose set of values for a given key are kept sorted; that is, they comprise a SortedSet.

Class Summary

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.
AbstractMapEntry<K,V>	Implementation of the equals, hashCode, and toString methods of Entry.
ArrayListMultimap<K,V>	Implementation of Multimap that uses an ArrayList to store the values for a given key.
Collections2	Provides static methods for working with Collection instances.
ConcurrentMultiset<E>	A multiset that supports concurrent modifications and that provides atomic versions of most Multiset operations (exceptions where noted).
Constraints	Factories and utilities pertaining to the Constraint interface.
CustomConcurrentHashMap	A framework for concurrent hash map implementations.
CustomConcurrentHashMap.Builder	Builds a custom concurrent hash map.
EnumBiMap<K extends Enum<K>,V extends Enum<V>>	A BiMap backed by two EnumMap instances.
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.
EnumMultiset<E extends Enum<E>>	Multiset implementation backed by an EnumMap.
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.
ForwardingIterator<T>	An iterator which forwards all its method calls to another iterator.
ForwardingList<E>	A list which forwards all its method calls to another list.
ForwardingListIterator<E>	A list iterator which forwards all its method calls to another list iterator.
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.
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.
ForwardingSortedMap<K,V>	A sorted map which forwards all its method calls to another sorted map.
ForwardingSortedSet<E>	A sorted set which forwards all its method calls to another sorted set.
HashBiMap<K,V>	A BiMap backed by two HashMap instances.
HashMultimap<K,V>	Implementation of Multimap using hash tables.
HashMultiset<E>	Multiset implementation backed by a HashMap.
ImmutableBiMap<K,V>	An immutable BiMap with reliable user-specified iteration order.
ImmutableBiMap.Builder<K,V>	A builder for creating immutable bimap instances, especially public static final bimaps ("constant bimaps").
ImmutableCollection<E>	An immutable collection.
ImmutableList<E>	A high-performance, immutable, random-access List implementation.
ImmutableList.Builder<E>	A builder for creating immutable list instances, especially public static final lists ("constant lists").
ImmutableMap<K,V>	An immutable, hash-based Map with reliable user-specified iteration order.
ImmutableMap.Builder<K,V>	A builder for creating immutable map instances, especially public static final maps ("constant maps").
ImmutableMultimap<K,V>	An immutable ListMultimap with reliable user-specified key and value iteration order.
ImmutableMultimap.Builder<K,V>	A builder for creating immutable multimap instances, especially public static final multimaps ("constant multimaps").
ImmutableMultiset<E>	An immutable hash-based multiset.
ImmutableSet<E>	A high-performance, immutable Set with reliable, user-specified iteration order.
ImmutableSet.Builder<E>	A builder for creating immutable set instances, especially public static final sets ("constant sets").
ImmutableSortedSet<E>	An immutable SortedSet that stores its elements in a sorted array.
ImmutableSortedSet.Builder<E>	A builder for creating immutable sorted set instances, especially public static final sets ("constant sets"), with a given comparator.
Iterables	This class contains static utility methods that operate on or return objects of type Iterable.
Iterators	This class contains static utility methods that operate on or return objects of type Iterator.
LinkedHashMultimap<K,V>	Implementation of Multimap that does not allow duplicate key-value entries and that returns collections whose iterators follow the ordering in which the data was added to the multimap.
LinkedHashMultiset<E>	A Multiset implementation with predictable iteration order.
LinkedListMultimap<K,V>	An implementation of ListMultimap that supports deterministic iteration order for both keys and values.
Lists	Static utility methods pertaining to List instances.
MapConstraints	Factory and utilities pertaining to the MapConstraint interface.
MapMaker	A ConcurrentMap builder, providing any combination of these features: soft or weak keys, soft or weak values, timed expiration, and on-demand computation of values.
Maps	Static utility methods pertaining to Map instances.
Multimaps	Provides static methods acting on or generating a Multimap.
Multisets	Provides static utility methods for creating and working with Multiset instances.
ObjectArrays	Static utility methods pertaining to object arrays.
Ordering<T>	A comparator with added methods to support common functions.
Serialization	Provides static method for serializing collection classes.
Sets	Static utility methods pertaining to Set instances.
Sets.SetView<E>	An unmodifiable view of a set which may be backed by other sets; this view will change as the backing sets do.
TreeMultimap<K,V>	Implementation of Multimap whose keys and values are ordered by their natural ordering or by supplied comparators.
TreeMultiset<E>	Multiset implementation backed by a TreeMap.
UnmodifiableIterator<E>	An iterator that does not support remove().

Exception Summary

AsynchronousComputationException	Wraps an exception that occured during a computation in a different thread.
ComputationException	Wraps an exception that occured during a computation.

Package com.google.common.collect Description

This package contains generic collection interfaces and implementations, and other utilities for working with collections.

Collection Types

BiMap

An extension of Map that guarantees the uniqueness of its values as well as that of its keys. This is sometimes called an "invertible map," since the restriction on values enables it to support an inverse view -- which is another instance of BiMap.

Multiset

An extension of Collection that may contain duplicate values like a List, yet has order-independent equality like a Set. One typical use for a multiset is to represent a histogram.

Multimap

A new type, which is similar to Map, but may contain multiple entries with the same key. Some behaviors of Multimap are left unspecified and are provided only by the subtypes mentioned below.

SetMultimap

An extension of Multimap which has order-independent equality and does not allow duplicate entries; that is, while a key may appear twice in a SetMultimap, each must map to a different value. SetMultimap takes its name from the fact that the collection of values associated with a given key fulfills the Set contract.

ListMultimap

An extension of Multimap which permits duplicate entries, supports random access of values for a particular key, and has partially order-dependent equality as defined by ListMultimap.equals(Object). ListMultimap takes its name from the fact that the collection of values associated with a given key fulfills the List contract.

SortedSetMultimap

An extension of SetMultimap for which the collection values associated with a given key is a SortedSet.

ClassToInstanceMap

An extension of Map that associates a raw type with an instance of that type.

Collection Implementations

of List

ImmutableList

of Set

ImmutableSet

of SortedSet

ImmutableSortedSet

of Map

ImmutableMap

of BiMap

HashBiMap

EnumBiMap

EnumHashBiMap

of Multiset

ConcurrentMultiset

EnumMultiset

HashMultiset

ImmutableMultiset

LinkedHashMultiset

TreeMultiset

of Multimap

ArrayListMultimap

HashMultimap

ImmutableMultimap

LinkedHashMultimap

LinkedListMultimap

TreeMultimap

Skeletal implementations

AbstractIterator

UnmodifiableIterator

Classes of static utility methods

Collections2

Iterators

Iterables

Lists

Maps

Sets

Multisets

Multimaps

ObjectArrays

Serialization

Comparators

Ordering

Constraints

Constraint

Constraints

MapConstraint

MapConstraints

Forwarding collections

ForwardingCollection

ForwardingConcurrentMap

ForwardingIterator

ForwardingList

ForwardingListIterator

ForwardingMap

ForwardingMapEntry

ForwardingMultimap

ForwardingMultiset

ForwardingObject

ForwardingQueue

ForwardingSet

ForwardingSortedMap

ForwardingSortedSet

Common Behavior

The methods of this package always throw NullPointerException in response to a null value being supplied for any parameter that is not explicitly annotated as being @Nullable.

Author:

Mike Bostock, Kevin Bourrillion, Jared Levy