• Home
• org.wildfly
• wildfly-client-all
• 29.0.0.Final
• source code
• package-info.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

/*
 * 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.
 *
 * 
Immutable collections
 *
 * Implementations of JDK and Guava collection types whose contents will never change, and which
 * offer a few additional guarantees. For details, see {@link ImmutableCollection}.
 *
 * 
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 Comparators}
 *   
{@link Collections2}
 *   
{@link Iterators}
 *   
{@link Iterables}
 *   
{@link Lists}
 *   
{@link Maps}
 *   
{@link MoreCollectors}
 *   
{@link Queues}
 *   
{@link Sets}
 *   
{@link Multisets}
 *   
{@link Multimaps}
 *   
{@link Tables}
 *   
{@link ObjectArrays}
 *   
{@link Streams}
 * 
 *
 * 
Abstract implementations
 *
 * 

 *   
{@link AbstractIterator}
 *   
{@link AbstractSequentialIterator}
 *   
{@link UnmodifiableIterator}
 *   
{@link UnmodifiableListIterator}
 * 
 *
 * 
Forwarding collections
 *
 * We provide implementations of collection 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;