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
Guava is a suite of core and expanded libraries that include utility classes, google's collections, io classes, and much much more.
There is a newer version: 33.3.1-jre
Show newest version
/*
 * 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;