com.google.common.collect.package-info Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of guava Show documentation
Builds the guava lib. Requires the jsr305 be built first.
There is a newer version: 33.3.0-jre-r3
/*
 * Copyright (C) 2007 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Collection interfaces and implementations, and other utilities for collections. This package is a
 * part of the open-source Guava library.
 *
 * The classes in this package include:
 *
 * 
Immutable collections
 *
 * These are collections whose contents will never change. They also offer a few additional
 * guarantees (see {@link ImmutableCollection} for details). Implementations are available for both
 * the JDK collection types and the Guava collection types (listed below).
 *
 * Collection types
 *
 * 
 *   {@link Multimap}
 *   
A new type, which is similar to {@link java.util.Map}, but may contain multiple entries
 *       with the same key. Some behaviors of {@link Multimap} are left unspecified and are provided
 *       only by the subtypes mentioned below.
 *   
{@link ListMultimap}
 *   
An extension of {@link Multimap} which permits duplicate entries, supports random access of
 *       values for a particular key, and has partially order-dependent equality as defined
 *       by {@link ListMultimap#equals(Object)}. {@code ListMultimap} takes its name from the fact
 *       that the {@linkplain ListMultimap#get collection of values} associated with a given key
 *       fulfills the {@link java.util.List} contract.
 *   
{@link SetMultimap}
 *   
An extension of {@link Multimap} which has order-independent equality and does not allow
 *       duplicate entries; that is, while a key may appear twice in a {@code SetMultimap}, each
 *       must map to a different value. {@code SetMultimap} takes its name from the fact that the
 *       {@linkplain SetMultimap#get collection of values} associated with a given key fulfills the
 *       {@link java.util.Set} contract.
 *   
{@link SortedSetMultimap}
 *   
An extension of {@link SetMultimap} for which the {@linkplain SortedSetMultimap#get
 *       collection values} associated with a given key is a {@link java.util.SortedSet}.
 *   
{@link BiMap}
 *   
An extension of {@link java.util.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 {@linkplain BiMap#inverse inverse view} -- which is another
 *       instance of {@code BiMap}.
 *   
{@link Table}
 *   
A new type, which is similar to {@link java.util.Map}, but which indexes its values by an
 *       ordered pair of keys, a row key and column key.
 *   
{@link Multiset}
 *   
An extension of {@link java.util.Collection} that may contain duplicate values like a
 *       {@link java.util.List}, yet has order-independent equality like a {@link java.util.Set}.
 *       One typical use for a multiset is to represent a histogram.
 *   
{@link ClassToInstanceMap}
 *   
An extension of {@link java.util.Map} that associates a raw type with an instance of that
 *       type.
 * 
 *
 * Ranges
 *
 * 
 *   {@link Range}
 *   
{@link RangeMap}
 *   
{@link RangeSet}
 *   
{@link DiscreteDomain}
 *   
{@link ContiguousSet}
 * 
 *
 * Classes of static utility methods
 *
 * 
 *   {@link Collections2}
 *   
{@link Comparators}
 *   
{@link Iterables}
 *   
{@link Iterators}
 *   
{@link Lists}
 *   
{@link Maps}
 *   
{@link MoreCollectors}
 *   
{@link Multimaps}
 *   
{@link Multisets}
 *   
{@link ObjectArrays}
 *   
{@link Queues}
 *   
{@link Sets}
 *   
{@link Streams}
 *   
{@link Tables}
 * 
 *
 * Abstract implementations
 *
 * 
 *   {@link AbstractIterator}
 *   
{@link AbstractSequentialIterator}
 *   
{@link UnmodifiableIterator}
 *   
{@link UnmodifiableListIterator}
 * 
 *
 * Forwarding collections
 *
 * We provide implementations of collections that forward all method calls to a delegate collection
 * by default. Subclasses can override one or more methods to implement the decorator pattern. For
 * an example, see {@link ForwardingCollection}.
 *
 * Other
 *
 * 
 *   {@link EvictingQueue}
 *   
{@link Interner}, {@link Interners}
 *   
{@link MapMaker}
 *   
{@link MinMaxPriorityQueue}
 *   
{@link PeekingIterator}
 * 
 */
@CheckReturnValue
@ParametersAreNonnullByDefault
package com.google.common.collect;

import com.google.errorprone.annotations.CheckReturnValue;
import javax.annotation.ParametersAreNonnullByDefault;