All Downloads are FREE. Search and download functionalities are using the official Maven repository.

jersey.repackaged.com.google.common.collect.Multimap Maven / Gradle / Ivy

There is a newer version: 8.16.0
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.
 */

package jersey.repackaged.com.google.common.collect;

import jersey.repackaged.com.google.common.annotations.GwtCompatible;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Nullable;

/**
 * A collection that maps keys to values, similar to {@link Map}, but in which
 * each key may be associated with multiple values. You can visualize the
 * contents of a multimap either as a map from keys to nonempty
 * collections of values:
 *
 * 
    *
  • a → 1, 2 *
  • b → 3 *
* * ... or as a single "flattened" collection of key-value pairs: * *
    *
  • a → 1 *
  • a → 2 *
  • b → 3 *
* *

Important: although the first interpretation resembles how most * multimaps are implemented, the design of the {@code Multimap} API is * based on the second form. So, using the multimap shown above as an * example, the {@link #size} is {@code 3}, not {@code 2}, and the {@link * #values} collection is {@code [1, 2, 3]}, not {@code [[1, 2], [3]]}. For * those times when the first style is more useful, use the multimap's {@link * #asMap} view (or create a {@code Map>} in the first place). * *

Example

* *

The following code:

   {@code
 *
 *   ListMultimap multimap = ArrayListMultimap.create();
 *   for (President pres : US_PRESIDENTS_IN_ORDER) {
 *     multimap.put(pres.firstName(), pres.lastName());
 *   }
 *   for (String firstName : multimap.keySet()) {
 *     List lastNames = multimap.get(firstName);
 *     out.println(firstName + ": " + lastNames);
 *   }}
* * ... produces output such as:
   {@code
 *
 *   Zachary: [Taylor]
 *   John: [Adams, Adams, Tyler, Kennedy]
 *   George: [Washington, Bush, Bush]
 *   Grover: [Cleveland]
 *   ...}
* *

Views

* *

Much of the power of the multimap API comes from the view * collections it provides. These always reflect the latest state of the * multimap itself. When they support modification, the changes are * write-through (they automatically update the backing multimap). These * view collections are: * *

    *
  • {@link #asMap}, mentioned above
  • *
  • {@link #keys}, {@link #keySet}, {@link #values}, {@link #entries}, which * are similar to the corresponding view collections of {@link Map} *
  • and, notably, even the collection returned by {@link #get get(key)} is an * active view of the values corresponding to {@code key} *
* *

The collections returned by the {@link #replaceValues replaceValues} and * {@link #removeAll removeAll} methods, which contain values that have just * been removed from the multimap, are naturally not views. * *

Subinterfaces

* *

Instead of using the {@code Multimap} interface directly, prefer the * subinterfaces {@link ListMultimap} and {@link SetMultimap}. These take their * names from the fact that the collections they return from {@code get} behave * like (and, of course, implement) {@link List} and {@link Set}, respectively. * *

For example, the "presidents" code snippet above used a {@code * ListMultimap}; if it had used a {@code SetMultimap} instead, two presidents * would have vanished, and last names might or might not appear in * chronological order. * *

Warning: instances of type {@code Multimap} may not implement * {@link Object#equals} in the way you expect (multimaps containing the same * key-value pairs, even in the same order, may or may not be equal). The * recommended subinterfaces provide a much stronger guarantee. * *

Comparison to a map of collections

* *

Multimaps are commonly used in places where a {@code Map>} would otherwise have appeared. The differences include: * *

    *
  • There is no need to populate an empty collection before adding an entry * with {@link #put put}. *
  • {@code get} never returns {@code null}, only an empty collection. *
  • A key contained in the multimap always maps to at least one value. Any * operation that causes a key to have zero associated values has the effect * of removing that key from the multimap. *
  • The total entry count is available as {@link #size}. *
  • Many complex operations become easier; for example, {@code * Collections.min(multimap.values())} finds the smallest value across all * keys. *
* *

Implementations

* *

As always, prefer the immutable implementations, {@link * ImmutableListMultimap} and {@link ImmutableSetMultimap}. General-purpose * mutable implementations are listed above under "All Known Implementing * Classes". You can also create a custom multimap, backed by any {@code * Map} and {@link Collection} types, using the {@link Multimaps#newMultimap * Multimaps.newMultimap} family of methods. Finally, another popular way to * obtain a multimap is using {@link Multimaps#index Multimaps.index}. See * the {@link Multimaps} class for these and other static utilities related * to multimaps. * *

Other Notes

* *

All methods that modify the multimap are optional. The view collections * returned by the multimap may or may not be modifiable. Any modification * method that is not supported will throw {@link * UnsupportedOperationException}. * *

See the Guava User Guide article on * {@code Multimap}. * * @author Jared Levy * @since 2.0 (imported from Google Collections Library) */ @GwtCompatible public interface Multimap { // Query Operations /** Returns the number of key-value pairs in the multimap. */ int size(); /** Returns {@code true} if the multimap contains no key-value pairs. */ boolean isEmpty(); /** * Returns {@code true} if the multimap contains any values for the specified * key. * * @param key key to search for in multimap */ boolean containsKey(@Nullable Object key); /** * Returns {@code true} if the multimap contains the specified value for any * key. * * @param value value to search for in multimap */ boolean containsValue(@Nullable Object value); /** * Returns {@code true} if the multimap contains the specified key-value pair. * * @param key key to search for in multimap * @param value value to search for in multimap */ boolean containsEntry(@Nullable Object key, @Nullable Object value); // Modification Operations /** * Stores a key-value pair in the multimap. * *

Some multimap implementations allow duplicate key-value pairs, in which * case {@code put} always adds a new key-value pair and increases the * multimap size by 1. Other implementations prohibit duplicates, and storing * a key-value pair that's already in the multimap has no effect. * * @param key key to store in the multimap * @param value value to store in the multimap * @return {@code true} if the method increased the size of the multimap, or * {@code false} if the multimap already contained the key-value pair and * doesn't allow duplicates */ boolean put(@Nullable K key, @Nullable V value); /** * Removes a single key-value pair from the multimap. * * @param key key of entry to remove from the multimap * @param value value of entry to remove the multimap * @return {@code true} if the multimap changed */ boolean remove(@Nullable Object key, @Nullable Object value); // Bulk Operations /** * Stores a collection of values with the same key. * * @param key key to store in the multimap * @param values values to store in the multimap * @return {@code true} if the multimap changed */ boolean putAll(@Nullable K key, Iterable values); /** * Copies all of another multimap's key-value pairs into this multimap. The * order in which the mappings are added is determined by * {@code multimap.entries()}. * * @param multimap mappings to store in this multimap * @return {@code true} if the multimap changed */ boolean putAll(Multimap multimap); /** * Stores a collection of values with the same key, replacing any existing * values for that key. * * @param key key to store in the multimap * @param values values to store in the multimap * @return the collection of replaced values, or an empty collection if no * values were previously associated with the key. The collection * may be modifiable, but updating it will have no effect on the * multimap. */ Collection replaceValues(@Nullable K key, Iterable values); /** * Removes all values associated with a given key. * * @param key key of entries to remove from the multimap * @return the collection of removed values, or an empty collection if no * values were associated with the provided key. The collection * may be modifiable, but updating it will have no effect on the * multimap. */ Collection removeAll(@Nullable Object key); /** * Removes all key-value pairs from the multimap. */ void clear(); // Views /** * Returns a collection view containing the values associated with {@code key} * in this multimap, if any. Note that even when ({@code containsKey(key)} is * false, {@code get(key)} still returns an empty collection, not {@code * null}. * *

Changes to the returned collection will update the underlying multimap, * and vice versa. * * @param key key to search for in multimap * @return a view collection containing the zero or more values that the key * maps to */ Collection get(@Nullable K key); /** * Returns the set of all keys, each appearing once in the returned set. * Changes to the returned set will update the underlying multimap, and vice * versa. * * @return the collection of distinct keys */ Set keySet(); /** * Returns a collection, which may contain duplicates, of all keys. The number * of times of key appears in the returned multiset equals the number of * mappings the key has in the multimap. Changes to the returned multiset will * update the underlying multimap, and vice versa. * * @return a multiset with keys corresponding to the distinct keys of the * multimap and frequencies corresponding to the number of values that * each key maps to */ Multiset keys(); /** * Returns a collection of all values in the multimap. Changes to the returned * collection will update the underlying multimap, and vice versa. * * @return collection of values, which may include the same value multiple * times if it occurs in multiple mappings */ Collection values(); /** * Returns a collection of all key-value pairs. Changes to the returned * collection will update the underlying multimap, and vice versa. The entries * collection does not support the {@code add} or {@code addAll} operations. * * @return collection of map entries consisting of key-value pairs */ Collection> entries(); /** * Returns a map view that associates each key with the corresponding values * in the multimap. Changes to the returned map, such as element removal, will * update the underlying multimap. The map does not support {@code setValue()} * on its entries, {@code put}, or {@code putAll}. * *

When passed a key that is present in the map, {@code * asMap().get(Object)} has the same behavior as {@link #get}, returning a * live collection. When passed a key that is not present, however, {@code * asMap().get(Object)} returns {@code null} instead of an empty collection. * * @return a map view from a key to its collection of values */ Map> asMap(); // Comparison and hashing /** * Compares the specified object with this multimap for equality. Two * multimaps are equal when their map views, as returned by {@link #asMap}, * are also equal. * *

In general, two multimaps with identical key-value mappings may or may * not be equal, depending on the implementation. For example, two * {@link SetMultimap} instances with the same key-value mappings are equal, * but equality of two {@link ListMultimap} instances depends on the ordering * of the values for each key. * *

A non-empty {@link SetMultimap} cannot be equal to a non-empty * {@link ListMultimap}, since their {@link #asMap} views contain unequal * collections as values. However, any two empty multimaps are equal, because * they both have empty {@link #asMap} views. */ @Override boolean equals(@Nullable Object obj); /** * Returns the hash code for this multimap. * *

The hash code of a multimap is defined as the hash code of the map view, * as returned by {@link Multimap#asMap}. */ @Override int hashCode(); }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy