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

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

Go to download

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.0-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.
 */

package com.google.common.collect;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.CompatibleWith;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.BiConsumer;
import org.checkerframework.checker.nullness.qual.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]  // Remember, Quincy!
 * George: [Washington, Bush, Bush]
 * Grover: [Cleveland, Cleveland]        // Two, non-consecutive terms, rep'ing NJ!
 * ...
 * }
* *

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 and may or may not have the same {@code hashCode}. The recommended subinterfaces * provide much stronger guarantees. * *

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 is contained in the multimap if and only if it 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

* *

As with {@code Map}, the behavior of a {@code Multimap} is not specified if key objects * already present in the multimap change in a manner that affects {@code equals} comparisons. Use * caution if mutable objects are used as keys in a {@code Multimap}. * *

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 */ @GwtCompatible public interface Multimap { // Query Operations /** * Returns the number of key-value pairs in this multimap. * *

Note: this method does not return the number of distinct keys in the multimap, * which is given by {@code keySet().size()} or {@code asMap().size()}. See the opening section of * the {@link Multimap} class documentation for clarification. */ int size(); /** * Returns {@code true} if this multimap contains no key-value pairs. Equivalent to {@code size() * == 0}, but can in some cases be more efficient. */ boolean isEmpty(); /** * Returns {@code true} if this multimap contains at least one key-value pair with the key {@code * key}. */ boolean containsKey(@CompatibleWith("K") @Nullable Object key); /** * Returns {@code true} if this multimap contains at least one key-value pair with the value * {@code value}. */ boolean containsValue(@CompatibleWith("V") @Nullable Object value); /** * Returns {@code true} if this multimap contains at least one key-value pair with the key {@code * key} and the value {@code value}. */ boolean containsEntry( @CompatibleWith("K") @Nullable Object key, @CompatibleWith("V") @Nullable Object value); // Modification Operations /** * Stores a key-value pair in this 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. * * @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 */ @CanIgnoreReturnValue boolean put(@Nullable K key, @Nullable V value); /** * Removes a single key-value pair with the key {@code key} and the value {@code value} from this * multimap, if such exists. If multiple key-value pairs in the multimap fit this description, * which one is removed is unspecified. * * @return {@code true} if the multimap changed */ @CanIgnoreReturnValue boolean remove( @CompatibleWith("K") @Nullable Object key, @CompatibleWith("V") @Nullable Object value); // Bulk Operations /** * Stores a key-value pair in this multimap for each of {@code values}, all using the same key, * {@code key}. Equivalent to (but expected to be more efficient than): * *

{@code
   * for (V value : values) {
   *   put(key, value);
   * }
   * }
* *

In particular, this is a no-op if {@code values} is empty. * * @return {@code true} if the multimap changed */ @CanIgnoreReturnValue boolean putAll(@Nullable K key, Iterable values); /** * Stores all key-value pairs of {@code multimap} in this multimap, in the order returned by * {@code multimap.entries()}. * * @return {@code true} if the multimap changed */ @CanIgnoreReturnValue boolean putAll(Multimap multimap); /** * Stores a collection of values with the same key, replacing any existing values for that key. * *

If {@code values} is empty, this is equivalent to {@link #removeAll(Object) removeAll(key)}. * * @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. */ @CanIgnoreReturnValue Collection replaceValues(@Nullable K key, Iterable values); /** * Removes all values associated with the key {@code key}. * *

Once this method returns, {@code key} will not be mapped to any values, so it will not * appear in {@link #keySet()}, {@link #asMap()}, or any other views. * * @return the values that were removed (possibly empty). The returned collection may be * modifiable, but updating it will have no effect on the multimap. */ @CanIgnoreReturnValue Collection removeAll(@CompatibleWith("K") @Nullable Object key); /** Removes all key-value pairs from the multimap, leaving it {@linkplain #isEmpty empty}. */ void clear(); // Views /** * Returns a view collection of the values associated with {@code key} in this multimap, if any. * Note that when {@code containsKey(key)} is false, this returns an empty collection, not {@code * null}. * *

Changes to the returned collection will update the underlying multimap, and vice versa. */ Collection get(@Nullable K key); /** * Returns a view collection of all distinct keys contained in this multimap. Note that the * key set contains a key if and only if this multimap maps that key to at least one value. * *

Changes to the returned set will update the underlying multimap, and vice versa. However, * adding to the returned set is not possible. */ Set keySet(); /** * Returns a view collection containing the key from each key-value pair in this multimap, * without collapsing duplicates. This collection has the same size as this multimap, and * {@code keys().count(k) == get(k).size()} for all {@code k}. * *

Changes to the returned multiset will update the underlying multimap, and vice versa. * However, adding to the returned collection is not possible. */ Multiset keys(); /** * Returns a view collection containing the value from each key-value pair contained in * this multimap, without collapsing duplicates (so {@code values().size() == size()}). * *

Changes to the returned collection will update the underlying multimap, and vice versa. * However, adding to the returned collection is not possible. */ Collection values(); /** * Returns a view collection of all key-value pairs contained in this multimap, as {@link Entry} * instances. * *

Changes to the returned collection or the entries it contains will update the underlying * multimap, and vice versa. However, adding to the returned collection is not possible. */ Collection> entries(); /** * Performs the given action for all key-value pairs contained in this multimap. If an ordering is * specified by the {@code Multimap} implementation, actions will be performed in the order of * iteration of {@link #entries()}. Exceptions thrown by the action are relayed to the caller. * *

To loop over all keys and their associated value collections, write {@code * Multimaps.asMap(multimap).forEach((key, valueCollection) -> action())}. * * @since 21.0 */ default void forEach(BiConsumer action) { checkNotNull(action); entries().forEach(entry -> action.accept(entry.getKey(), entry.getValue())); } /** * Returns a view of this multimap as a {@code Map} from each distinct key to the nonempty * collection of that key's associated values. Note that {@code this.asMap().get(k)} is equivalent * to {@code this.get(k)} only when {@code k} is a key contained in the multimap; otherwise it * returns {@code null} as opposed to an empty collection. * *

Changes to the returned map or the collections that serve as its values will update the * underlying multimap, and vice versa. The map does not support {@code put} or {@code putAll}, * nor do its entries support {@link Entry#setValue setValue}. */ 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}. * *

In general, two multimaps with identical key-value mappings may or may not have the same * hash codes, depending on the implementation. For example, two {@link SetMultimap} instances * with the same key-value mappings will have the same {@code hashCode}, but the {@code hashCode} * of {@link ListMultimap} instances depends on the ordering of the values for each key. */ @Override int hashCode(); }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy