Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES

@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
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.
ListMultimap<K,V> | A `Multimap` that can hold duplicate key-value pairs and that maintains the insertion ordering of values for a given key.
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.
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.
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.
ConcurrentHashMultiset<E> | A multiset that supports concurrent modifications and that provides atomic versions of most `Multiset` operations (exceptions where noted).
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").
ImmutableClassToInstanceMap<B> | A class-to-instance map backed by an `ImmutableMap`.
ImmutableClassToInstanceMap.Builder<B> | A builder for creating immutable class-to-instance maps.
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").
ImmutableListMultimap<K,V> | An immutable `ListMultimap` with reliable user-specified key and value iteration order.
ImmutableListMultimap.Builder<K,V> | A builder for creating immutable `ListMultimap` instances, especially `public static final` multimaps ("constant multimaps").
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 `Multimap`.
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.
ImmutableMultiset.Builder<E> | A builder for creating immutable multiset instances, especially `public static final` multisets ("constant multisets").
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").
ImmutableSetMultimap<K,V> | An immutable `SetMultimap` with reliable user-specified key and value iteration order.
ImmutableSetMultimap.Builder<K,V> | A builder for creating immutable `SetMultimap` instances, especially `public static final` multimaps ("constant multimaps").
ImmutableSortedMap<K,V> | An immutable `SortedMap`.
ImmutableSortedMap.Builder<K,V> | A builder for creating immutable sorted map instances, especially `public static final` maps ("constant maps").
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.
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.
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 added methods to support common functions.
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> | A multiset which maintains the ordering of its elements, according to either their natural order or an explicit `Comparator`.
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

`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`.
`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.
`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`.
`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`
`MapMaker` (produced by)

### of `SortedMap`

`ImmutableSortedMap`

### of `Multimap`

`ImmutableMultimap`
`Multimaps.newMultimap(java.util.Map>, com.google.common.base.Supplier>)`

### of `ListMultimap`

`ImmutableListMultimap`
`ArrayListMultimap`
`LinkedListMultimap`
`Multimaps.newListMultimap(java.util.Map>, com.google.common.base.Supplier>)`

### of `SetMultimap`

`ImmutableSetMultimap`
`HashMultimap`
`LinkedHashMultimap`
`TreeMultimap`
`Multimaps.newSetMultimap(java.util.Map>, com.google.common.base.Supplier>)`
`Multimaps.newSortedSetMultimap(java.util.Map>, com.google.common.base.Supplier>)`

### of `Multiset`

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

### of `BiMap`

`HashBiMap`
`EnumBiMap`
`EnumHashBiMap`

### of `ClassToInstanceMap`

`ImmutableClassToInstanceMap`
`MutableClassToInstanceMap`

## Skeletal implementations

`AbstractIterator`
`UnmodifiableIterator`

## Utilities

`Collections2`
`Iterators`
`Iterables`
`Lists`
`Maps`
`Ordering`
`Sets`
`Multisets`
`Multimaps`
`ObjectArrays`

## Forwarding collections

`ForwardingCollection`
`ForwardingConcurrentMap`
`ForwardingIterator`
`ForwardingList`
`ForwardingListIterator`
`ForwardingMap`
`ForwardingMapEntry`
`ForwardingMultimap`
`ForwardingMultiset`
`ForwardingObject`
`ForwardingQueue`
`ForwardingSet`
`ForwardingSortedMap`
`ForwardingSortedSet`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES