@ParametersAreNonnullByDefault

# Package com.google.common.collect

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

See: Description

- Interface Summary
  Interface | Description
  --- | ---
  BiMap<K,V> | A bimap (or "bidirectional map") is a map that preserves the uniqueness of its values as well as that of its keys.
  ClassToInstanceMap<B> | A map, each entry of which maps a Java raw type to an instance of that type.
  Interner<E> | Provides equivalent behavior to `String.intern()` for other immutable types.
  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> | Deprecated Use `Preconditions` for basic checks.
  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.
  Maps.EntryTransformer<K,V1,V2> | A transformation of the value of a key-value pair, using both key and value as inputs.
  Multimap<K,V> | A collection that maps keys to values, similar to `Map`, but in which each key may be associated with multiple values.
  Multiset<E> | A collection that supports order-independent equality, like `Set`, but may have duplicate elements.
  Multiset.Entry<E> | An unmodifiable element-count pair for a multiset.
  PeekingIterator<E> | An iterator that supports a one-element lookahead while iterating.
  RangeMap<K extends java.lang.Comparable,V> | A mapping from disjoint nonempty ranges to non-null values.
  RangeSet<C extends java.lang.Comparable> | A set comprising zero or more nonempty, disconnected ranges of type `C`.
  RowSortedTable<R,C,V> | Interface that extends `Table` and whose rows are sorted.
  SetMultimap<K,V> | A `Multimap` that cannot hold duplicate key-value pairs.
  SortedMapDifference<K,V> | An object representing the differences between two sorted maps.
  SortedMultiset<E> | A `Multiset` which maintains the ordering of its elements, according to either their natural order or an explicit `Comparator`.
  SortedSetMultimap<K,V> | A `SetMultimap` whose set of values for a given key are kept sorted; that is, they comprise a `SortedSet`.
  Table<R,C,V> | A collection that associates an ordered pair of keys, called a row key and a column key, with a single value.
  Table.Cell<R,C,V> | Row key / column key / value triplet corresponding to a mapping in a table.

- Class Summary
  Class | Description
  --- | ---
  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.
  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.
  ArrayListMultimap<K,V> | Implementation of `Multimap` that uses an `ArrayList` to store the values for a given key.
  ArrayTable<R,C,V> | Fixed-size `Table` implementation backed by a two-dimensional array.
  BinaryTreeTraverser<T> | A variant of `TreeTraverser` for binary trees, providing additional traversals specific to binary trees.
  Collections2 | Provides static methods for working with `Collection` instances.
  ComparisonChain | A utility for performing a chained comparison statement.
  ConcurrentHashMultiset<E> | A multiset that supports concurrent modifications and that provides atomic versions of most `Multiset` operations (exceptions where noted).
  ContiguousSet<C extends java.lang.Comparable> | A sorted set of contiguous values in a given `DiscreteDomain`.
  DiscreteDomain<C extends java.lang.Comparable> | A descriptor for a discrete `Comparable` domain such as all `Integer` instances.
  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 backed by an `EnumMap`.
  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.
  FluentIterable<E> | An expanded `Iterable` API, providing functionality similar to Java 8's powerful streams library in a slightly different way.
  ForwardingBlockingDeque<E> | A `BlockingDeque` which forwards all its method calls to another `BlockingDeque`.
  ForwardingCollection<E> | A collection which forwards all its method calls to another collection.
  ForwardingConcurrentMap<K,V> | A concurrent map which forwards all its method calls to another concurrent map.
  ForwardingDeque<E> | A deque which forwards all its method calls to another deque.
  ForwardingIterator<T> | An iterator which forwards all its method calls to another iterator.
  ForwardingList<E> | A list which forwards all its method calls to another list.
  ForwardingListIterator<E> | A list iterator which forwards all its method calls to another list iterator.
  ForwardingListMultimap<K,V> | A list multimap which forwards all its method calls to another list multimap.
  ForwardingMap<K,V> | A map which forwards all its method calls to another map.
  ForwardingMapEntry<K,V> | A map entry which forwards all its method calls to another map entry.
  ForwardingMultimap<K,V> | A multimap which forwards all its method calls to another multimap.
  ForwardingMultiset<E> | A multiset which forwards all its method calls to another multiset.
  ForwardingNavigableMap<K,V> | A navigable map which forwards all its method calls to another navigable map.
  ForwardingNavigableSet<E> | A navigable set which forwards all its method calls to another navigable set.
  ForwardingObject | An abstract base class for implementing the decorator pattern.
  ForwardingQueue<E> | A queue which forwards all its method calls to another queue.
  ForwardingSet<E> | A set which forwards all its method calls to another set.
  ForwardingSetMultimap<K,V> | A set multimap which forwards all its method calls to another set multimap.
  ForwardingSortedMap<K,V> | A sorted map which forwards all its method calls to another sorted map.
  ForwardingSortedMultiset<E> | A sorted multiset which forwards all its method calls to another sorted multiset.
  ForwardingSortedSet<E> | A sorted set which forwards all its method calls to another sorted set.
  ForwardingSortedSetMultimap<K,V> | A sorted set multimap which forwards all its method calls to another sorted set multimap.
  ForwardingTable<R,C,V> | A table which forwards all its method calls to another table.
  HashBasedTable<R,C,V> | Implementation of `Table` using hash tables.
  HashBiMap<K,V> | A `BiMap` backed by two hash tables.
  HashMultimap<K,V> | Implementation of `Multimap` using hash tables.
  HashMultiset<E> | Multiset implementation backed by a `HashMap`.
  ImmutableBiMap<K,V> | A `BiMap` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableBiMap.Builder<K,V> | A builder for creating immutable bimap instances, especially `public static final` bimaps ("constant bimaps").
  ImmutableClassToInstanceMap<B> | A `ClassToInstanceMap` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableClassToInstanceMap.Builder<B> | A builder for creating immutable class-to-instance maps.
  ImmutableCollection<E> | A `Collection` whose contents will never change, and which offers a few additional guarantees detailed below.
  ImmutableCollection.Builder<E> | Abstract base class for builders of `ImmutableCollection` types.
  ImmutableList<E> | A `List` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableList.Builder<E> | A builder for creating immutable list instances, especially `public static final` lists ("constant lists").
  ImmutableListMultimap<K,V> | A `ListMultimap` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableListMultimap.Builder<K,V> | A builder for creating immutable `ListMultimap` instances, especially `public static final` multimaps ("constant multimaps").
  ImmutableMap<K,V> | A `Map` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableMap.Builder<K,V> | A builder for creating immutable map instances, especially `public static final` maps ("constant maps").
  ImmutableMultimap<K,V> | A `Multimap` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableMultimap.Builder<K,V> | A builder for creating immutable multimap instances, especially `public static final` multimaps ("constant multimaps").
  ImmutableMultiset<E> | A `Multiset` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableMultiset.Builder<E> | A builder for creating immutable multiset instances, especially `public static final` multisets ("constant multisets").
  ImmutableRangeMap<K extends java.lang.Comparable<?>,V> | A `RangeMap` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableRangeMap.Builder<K extends java.lang.Comparable<?>,V> | A builder for immutable range maps.
  ImmutableRangeSet<C extends java.lang.Comparable> | A `RangeSet` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableRangeSet.Builder<C extends java.lang.Comparable<?>> | A builder for immutable range sets.
  ImmutableSet<E> | A `Set` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableSet.Builder<E> | A builder for creating `ImmutableSet` instances.
  ImmutableSetMultimap<K,V> | A `SetMultimap` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableSetMultimap.Builder<K,V> | A builder for creating immutable `SetMultimap` instances, especially `public static final` multimaps ("constant multimaps").
  ImmutableSortedMap<K,V> | A `NavigableMap` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableSortedMap.Builder<K,V> | A builder for creating immutable sorted map instances, especially `public static final` maps ("constant maps").
  ImmutableSortedMultiset<E> | A `SortedMultiset` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableSortedMultiset.Builder<E> | A builder for creating immutable multiset instances, especially `public static final` multisets ("constant multisets").
  ImmutableSortedSet<E> | A `NavigableSet` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableSortedSet.Builder<E> | A builder for creating immutable sorted set instances, especially `public static final` sets ("constant sets"), with a given comparator.
  ImmutableTable<R,C,V> | A `Table` whose contents will never change, with many other important properties detailed at `ImmutableCollection`.
  ImmutableTable.Builder<R,C,V> | A builder for creating immutable table instances, especially `public static final` tables ("constant tables").
  Interners | Contains static methods pertaining to instances of `Interner`.
  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 | Deprecated Use `Preconditions` for basic checks.
  MapMaker | A builder of `ConcurrentMap` instances having any combination of the following features: keys or values automatically wrapped in weak or soft references notification of evicted (or otherwise removed) entries
  Maps | Static utility methods pertaining to `Map` instances (including instances of `SortedMap`, `BiMap`, etc.).
  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.
  MultimapBuilder<K0,V0> | A builder for a multimap implementation that allows customization of the backing map and value collection implementations used in a particular multimap.
  MultimapBuilder.ListMultimapBuilder<K0,V0> | A specialization of `MultimapBuilder` that generates `ListMultimap` instances.
  MultimapBuilder.MultimapBuilderWithKeys<K0> | An intermediate stage in a `MultimapBuilder` in which the key-value collection map implementation has been specified, but the value collection implementation has not.
  MultimapBuilder.SetMultimapBuilder<K0,V0> | A specialization of `MultimapBuilder` that generates `SetMultimap` instances.
  MultimapBuilder.SortedSetMultimapBuilder<K0,V0> | A specialization of `MultimapBuilder` that generates `SortedSetMultimap` instances.
  Multimaps | Provides static methods acting on or generating a `Multimap`.
  Multisets | Provides static utility methods for creating and working with `Multiset` instances.
  MutableClassToInstanceMap<B> | A mutable class-to-instance map backed by an arbitrary user-provided map.
  ObjectArrays | Static utility methods pertaining to object arrays.
  Ordering<T> | A comparator, with additional methods to support common operations.
  Queues | Static utility methods pertaining to `Queue` and `Deque` instances.
  Range<C extends java.lang.Comparable> | A range (or "interval") defines the boundaries around a contiguous span of values of some `Comparable` type; for example, "integers from 1 to 100 inclusive." Note that it is not possible to iterate over these contained values.
  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.
  Tables | Provides static methods that involve a `Table`.
  TreeBasedTable<R,C,V> | Implementation of `Table` whose row keys and column keys are ordered by their natural ordering or by supplied comparators.
  TreeMultimap<K,V> | Implementation of `Multimap` whose keys and values are ordered by their natural ordering or by supplied comparators.
  TreeMultiset<E> | A multiset which maintains the ordering of its elements, according to either their natural order or an explicit `Comparator`.
  TreeRangeMap<K extends java.lang.Comparable,V> | An implementation of `RangeMap` based on a `TreeMap`, supporting all optional operations.
  TreeRangeSet<C extends java.lang.Comparable<?>> | An implementation of `RangeSet` backed by a `TreeMap`.
  TreeTraverser<T> | Views elements of a type `T` as nodes in a tree, and provides methods to traverse the trees induced by this traverser.
  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)`.

- Enum Summary
  Enum | Description
  --- | ---
  BoundType | Indicates whether an endpoint of some range is contained in the range itself ("closed") or not ("open").

- Exception Summary
  Exception | Description
  --- | ---
  ComputationException | Wraps an exception that occurred during a computation.

## Package com.google.common.collect Description

This package contains generic collection interfaces and implementations, and other utilities for working with collections. It is a part of the open-source Guava libraries.

## 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.
`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.
`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.
`SortedSetMultimap`
  An extension of `SetMultimap` for which the collection values associated with a given key is a `SortedSet`.
`Table`
  A new type, which is similar to `Map`, but which indexes its values by an ordered pair of keys, a row key and column key.
`ClassToInstanceMap`
  An extension of `Map` that associates a raw type with an instance of that type.

## Collection Implementations

### of `List`

- `ImmutableList`

### of `Set`

- `ImmutableSet`
- `ImmutableSortedSet`
- `ContiguousSet` (see `Range`)

### of `Map`

- `ImmutableMap`
- `ImmutableSortedMap`
- `MapMaker`

### of `BiMap`

- `ImmutableBiMap`
- `HashBiMap`
- `EnumBiMap`
- `EnumHashBiMap`

### of `Multiset`

- `ImmutableMultiset`
- `HashMultiset`
- `LinkedHashMultiset`
- `TreeMultiset`
- `EnumMultiset`
- `ConcurrentHashMultiset`

### of `Multimap`

- `ImmutableMultimap`
- `ImmutableListMultimap`
- `ImmutableSetMultimap`
- `ArrayListMultimap`
- `HashMultimap`
- `TreeMultimap`
- `LinkedHashMultimap`
- `LinkedListMultimap`

### of `Table`

- `ImmutableTable`
- `ArrayTable`
- `HashBasedTable`
- `TreeBasedTable`

### of `ClassToInstanceMap`

- `ImmutableClassToInstanceMap`
- `MutableClassToInstanceMap`

## Classes of static utility methods

- `Collections2`
- `Iterators`
- `Iterables`
- `Lists`
- `Maps`
- `Queues`
- `Sets`
- `Multisets`
- `Multimaps`
- `Tables`
- `ObjectArrays`

## Comparison

- `Ordering`
- `ComparisonChain`

## Abstract implementations

- `AbstractIterator`
- `AbstractSequentialIterator`
- `ImmutableCollection`
- `UnmodifiableIterator`
- `UnmodifiableListIterator`

## Ranges

- `Range`
- `RangeMap`
- `DiscreteDomain`
- `ContiguousSet`

## Other

- `Interner`, `Interners`
- `Constraint`, `Constraints`
- `MapConstraint`, `MapConstraints`
- `MapDifference`, `SortedMapDifference`
- `MinMaxPriorityQueue`
- `PeekingIterator`

## Forwarding collections

- `ForwardingCollection`
- `ForwardingConcurrentMap`
- `ForwardingIterator`
- `ForwardingList`
- `ForwardingListIterator`
- `ForwardingListMultimap`
- `ForwardingMap`
- `ForwardingMapEntry`
- `ForwardingMultimap`
- `ForwardingMultiset`
- `ForwardingNavigableMap`
- `ForwardingNavigableSet`
- `ForwardingObject`
- `ForwardingQueue`
- `ForwardingSet`
- `ForwardingSetMultimap`
- `ForwardingSortedMap`
- `ForwardingSortedMultiset`
- `ForwardingSortedSet`
- `ForwardingSortedSetMultimap`
- `ForwardingTable`