/* * 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 com.google.common.collect; import 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: * *
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 The following code: 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:
*
* 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.
*
* 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.
*
* Multimaps are commonly used in places where a {@code Map 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.
*
* 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 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 extends V> 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 extends K, ? extends V> 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 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 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 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();
}
Example
*
* {@code
*
* ListMultimap
*
* ... produces output such as: {@code
*
* Zachary: [Taylor]
* John: [Adams, Adams, Tyler, Kennedy]
* George: [Washington, Bush, Bush]
* Grover: [Cleveland]
* ...}
*
* Views
*
*
*
*
* Subinterfaces
*
* Comparison to a map of collections
*
*
*
*
* Implementations
*
* Other Notes
*
*