提升编程效率的利器: 解析Google Guava库之集合篇Multimap（二）
提升编程效率的利器: 解析Google Guava库之集合篇Multimap（二）
一、Multimap 的核心特点
Multimap 最核心的特点就是支持一个键对应多个值。这意味着我们可以向 Multimap 中添加一个键和多个值，并且可以通过键来检索到对应的值集合。这种一对多的映射关系在很多场景下都非常有用，比如处理用户的多个邮箱地址、一个订单包含多个商品等。
除了支持多值映射外，Multimap 还具有以下特点：
- 值集合不必唯一： 与 SetMultimap 不同，普通的 Multimap 允许值重复。如果你需要值集合中的元素唯一，可以选择使用 SetMultimap。
- 顺序可保留也可不保留： Guava 提供了多种 Multimap 的实现，其中一些实现可以保留元素插入的顺序，如 LinkedHashMultimap，而另一些实现则不保证顺序，如 HashMultimap。你可以根据具体需求选择合适的实现。
- 空键和空值的支持： Multimap 允许使用 null 作为键或值，但是不同的实现可能会有不同的限制。在选择具体的 Multimap 实现时，需要注意其对空键和空值的处理方式。
- 丰富的视图： Multimap 提供了多种视图来访问和操作其中的元素。通过 asMap() 方法，你可以获取一个将键映射到对应值集合的 Map 视图；通过 entries() 方法，你可以获取一个包含所有键值对集合的视图。这些视图提供了方便的方式来遍历和操作 Multimap 中的元素。
二、Multimap常用方法
直接上代码吧，下面是一个结合Guava库中Multimap常用方法的示例：
首先，我们需要添加Guava库到项目中，以便使用Multimap。如果你使用的是Maven，你可以在pom.xml中添加以下依赖：
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1-jre</version> <!-- 请检查最新版本 -->
</dependency>import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import java.util.Collection;
import java.util.Map;
public class MultimapExample {
public static void main(String[] args) {
// 创建一个Multimap实例
Multimap<String, Integer> multimap = ArrayListMultimap.create();
// 使用put方法添加键值对
multimap.put("apple", 1);
multimap.put("apple", 2);
multimap.put("banana", 3);
multimap.put("orange", 4);
multimap.put("orange", 5);
multimap.put("orange", 6);
// 使用putAll方法添加多个键值对
Map<String, Integer> moreFruits = Map.of("grape", 7, "grape", 8, "kiwi", 9);
multimap.putAll(moreFruits);
// 使用get方法获取键对应的所有值
System.out.println("Apples: " + multimap.get("apple")); // 输出 [1, 2]
// 使用containsKey和containsValue检查键和值是否存在
System.out.println("Contains key 'apple'? " + multimap.containsKey("apple")); // 输出 true
System.out.println("Contains value 6? " + multimap.containsValue(6)); // 输出 true
// 使用remove方法移除单个键值对
boolean removed = multimap.remove("banana", 3);
System.out.println("Removed banana=3? " + removed); // 输出 true
// 使用removeAll方法移除一个键及其所有值
multimap.removeAll("kiwi");
System.out.println("Kiwis: " + multimap.get("kiwi")); // 输出 []
// 使用keySet获取所有不同的键
System.out.println("Unique keys: " + multimap.keySet()); // 输出可能包含 [orange, apple, grape, banana] (注意banana和kiwi可能已被移除)
// 使用values获取所有值（包括重复值）
System.out.println("All values: " + multimap.values()); // 输出包含所有值的集合
// 使用entries获取所有键值对
System.out.println("Entries: " + multimap.entries()); // 输出所有键值对
// 使用asMap获取每个键对应值的集合的视图
System.out.println("As Map: " + multimap.asMap()); // 输出类似 {orange=[4, 5, 6], apple=[1, 2], grape=[7, 8]}
// 使用size方法获取键值对总数
System.out.println("Size of multimap: " + multimap.size()); // 输出当前multimap中键值对的总数
// 使用isEmpty检查multimap是否为空
System.out.println("Is multimap empty? " + multimap.isEmpty()); // 根据multimap内容输出 true 或 false
}
}请注意，由于Multimap允许存储重复的键，并且每个键可以关联多个值，因此上述代码中的输出可能会根据键的插入和删除顺序而有所不同。此外，keySet、values和entries返回的集合视图会随Multimap的更改而动态更新。
在实际应用中，你可以根据具体需求选择使用Multimap的哪种实现（如ArrayListMultimap、HashMultimap、LinkedListMultimap等），并调整上述示例以满足你的场景。
三、常用的 Multimap 实现
Guava 提供了多种 Multimap 的实现，每种实现都有其特定的用途和性能特点。以下是一些常用的 Multimap 实现及其适用场景：
1. ArrayListMultimap
如果你需要保留值的插入顺序，并且希望获得较好的迭代性能，那么 ArrayListMultimap 是一个不错的选择。它基于 ArrayList 实现，提供了常数时间的 get 操作。但是需要注意的是，在某些情况下，如遍历所有键值对时，性能可能不如其他实现。
2. HashMultimap
如果你对值的顺序不关心，但是需要快速的键查找性能，那么 HashMultimap 是一个很好的选择。它基于 HashMap 实现，提供了高效的键查找操作。但是需要注意的是，HashMultimap 不允许 null 键或值。
3. LinkedHashMultimap
如果你既需要快速的键查找性能，又希望保留值的插入顺序，那么 LinkedHashMultimap 是一个很好的折中选择。它结合了 HashMap 和 LinkedList 的特点，既提供了快速的键查找性能，又保留了元素插入的顺序。
4. TreeMultimap
如果你需要按键的顺序访问 Multimap 中的元素，并且希望根据键进行排序，那么 TreeMultimap 是一个很好的选择。它基于 TreeMap 实现，可以根据键的自然顺序或提供的 Comparator 对键进行排序。
我们将模拟一个简单的社交网络，其中有用户、他们的朋友以及他们之间的互动
import com.google.common.collect.*;
import java.util.*;
public class SocialNetwork {
public static void main(String[] args) {
// 使用ArrayListMultimap来保存用户的朋友列表，保留插入顺序
ArrayListMultimap<String, String> friendsByUser = ArrayListMultimap.create();
// 使用HashMultimap来保存用户对朋友的点赞，不保证顺序
HashMultimap<String, String> likesByUser = HashMultimap.create();
// 使用LinkedHashMultimap来保存用户的消息，保留插入顺序
LinkedHashMultimap<String, String> messagesByUser = LinkedHashMultimap.create();
// 使用TreeMultimap来保存用户的活动日志，按键（时间戳）排序
TreeMultimap<Long, String> activityLog = TreeMultimap.create();
// 添加一些朋友
friendsByUser.putAll("Alice", Arrays.asList("Bob", "Charlie", "David"));
friendsByUser.putAll("Bob", Arrays.asList("Alice", "Charlie"));
friendsByUser.put("Charlie", "David");
// 添加一些点赞
likesByUser.put("Alice", "Bob's post");
likesByUser.put("Alice", "Charlie's photo");
likesByUser.put("Bob", "Charlie's photo");
likesByUser.putAll("Charlie", Arrays.asList("Alice's status", "David's video"));
// 添加一些消息
messagesByUser.put("Alice", "Hi Bob!");
messagesByUser.put("Alice", "How are you Charlie?");
messagesByUser.put("Bob", "Charlie, where are you?");
messagesByUser.putAll("Charlie", Arrays.asList("Here I am!", "Alice, check this out!"));
// 添加一些活动日志（假设时间戳是简单的顺序数字）
activityLog.put(1L, "Alice added a new friend");
activityLog.put(2L, "Bob liked a photo");
activityLog.put(3L, "Charlie sent a message");
// 打印出Alice的朋友列表
System.out.println("Alice's friends: " + friendsByUser.get("Alice"));
// 打印出点赞了Charlie的照片的用户
for (String user : likesByUser.keys()) {
if (likesByUser.containsEntry(user, "Charlie's photo")) {
System.out.println(user + " liked Charlie's photo");
}
}
// 打印出Alice发送的所有消息
for (String message : messagesByUser.get("Alice")) {
System.out.println("Alice said: " + message);
}
// 打印出按时间顺序的所有活动日志
for (Map.Entry<Long, String> entry : activityLog.entries()) {
System.out.println("Timestamp: " + entry.getKey() + ", Event: " + entry.getValue());
}
// 假设我们想要移除Bob作为Alice的朋友
friendsByUser.remove("Alice", "Bob");
// 再次打印出Alice的朋友列表，确认Bob已被移除
System.out.println("Alice's friends after removing Bob: " + friendsByUser.get("Alice"));
}
}这个示例展示了如何使用不同类型的Multimap来存储和处理社交网络中的数据。我们使用了put，putAll，get，containsEntry，keys，entries和remove等方法来操作Multimap。每种Multimap都有其特定的用途，例如ArrayListMultimap和LinkedHashMultimap保留了插入顺序，而HashMultimap则提供了快速的无序查找，TreeMultimap则按键排序。
5. ImmutableSetMultimap 和 ImmutableListMultimap
如果你需要一个不可变的 Multimap，即一旦创建就不能修改，那么可以选择 ImmutableSetMultimap 或 ImmutableListMultimap。它们在多线程环境中非常有用，因为它们是线程安全的，并且提供了高效的内存使用。
示例请参考：提升编程效率的利器: 解析Google Guava库之集合篇（一）
6.SynchronizedMultimap
这个实现提供了线程安全的Multimap。它通过在每个方法上添加synchronized关键字来实现线程安全。需要注意的是，迭代操作需要额外的同步措施，因为迭代器的hasNext、next和remove方法之间必须保持同步。
import com.google.common.collect.*;
import java.util.Collections;
public class SynchronizedMultimapExample {
public static void main(String[] args) {
// 创建一个非线程安全的 Multimap
Multimap<String, Integer> multimap = ArrayListMultimap.create();
// 获得一个线程安全的 Multimap
Multimap<String, Integer> synchronizedMultimap = Multimaps.synchronizedMultimap(multimap);
// 在多线程环境中安全地使用 synchronizedMultimap
// 注意：迭代时需要在 synchronized 块中进行
synchronized (synchronizedMultimap) {
for (Map.Entry<String, Integer> entry : synchronizedMultimap.entries()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
// 添加元素
synchronizedMultimap.put("test", 1);
synchronizedMultimap.put("test", 2);
synchronizedMultimap.put("another", 3);
// 再次安全地迭代
synchronized (synchronizedMultimap) {
for (String key : synchronizedMultimap.keySet()) {
System.out.println(key + " : " + synchronizedMultimap.get(key));
}
}
}
}在上面的代码中，我们先创建了一个非线程安全的 ArrayListMultimap，然后使用 Multimaps.synchronizedMultimap 方法获得了一个线程安全的 Multimap。我们展示了如何在多线程环境中安全地使用这个 Multimap，包括在迭代时需要在 synchronized 块中进行以避免并发修改异常。
请注意，Multimaps.synchronizedMultimap 返回的 Multimap 并不是 SynchronizedMultimap 类型，而是原始 Multimap 的一个线程安全视图。在实际代码中，你不需要（也不能）直接实例化一个 SynchronizedMultimap，而是应该使用 Multimaps.synchronizedMultimap 方法来获取线程安全的视图。
7.ForwardingMultimap
这是一个装饰器模式的实现，允许你在不修改原始Multimap实现的情况下添加或覆盖行为。你可以通过扩展ForwardingMultimap类并重写需要定制的方法来实现自定义逻辑。
下面是一个简单的示例，演示了如何使用 ForwardingMultimap 来创建一个自定义的 Multimap，该 Multimap 在每次添加元素时都会打印一条消息。
import com.google.common.collect.*;
import java.util.Collection;
import java.util.Map;
public class CustomForwardingMultimap<K, V> extends ForwardingMultimap<K, V> {
private final Multimap<K, V> delegate;
public CustomForwardingMultimap(Multimap<K, V> delegate) {
this.delegate = delegate;
}
@Override
protected Multimap<K, V> delegate() {
return delegate;
}
@Override
public Multimap<K, V> putAll(K key, Iterable<? extends V> values) {
System.out.println("Adding values for key: " + key);
return super.putAll(key, values);
}
public static void main(String[] args) {
Multimap<String, Integer> multimap = ArrayListMultimap.create();
CustomForwardingMultimap<String, Integer> customMultimap = new CustomForwardingMultimap<>(multimap);
customMultimap.putAll("test", Arrays.asList(1, 2, 3));
System.out.println(customMultimap); // Outputs: {test=[1, 2, 3]}
}
}在上面的代码中，我们创建了一个 CustomForwardingMultimap 类，它扩展了 ForwardingMultimap。我们通过覆盖 putAll 方法来添加自定义行为（在这种情况下，是打印一条消息）。所有其他方法（如 get，size 等）将直接委托给底层 Multimap 实现。
四、总结
Guava 的 Multimap 提供了一种灵活和方便的方式来处理一对多的映射关系。通过选择合适的实现，我们可以满足不同的需求，并获得更好的性能和易用性。在使用 Multimap 时，我们应该根据具体的需求和性能要求来选择合适的实现，并且充分利用其提供的视图和操作方法来简化代码和提高效率。
术因分享而日新，每获新知，喜溢心扉。
诚邀关注公众号 『
码到三十五』 ，获取更多技术资料。