提升编程效率的利器: 解析Google Guava库之集合篇(二)

在处理一对多的映射关系时,Java 标准库提供的 Map 接口可能无法满足我们的需求。这时,Google Guava 库中的 Multimap 就成为了一个非常有用的工具。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.guavagroupId>  
    <artifactId>guavaartifactId>  
    <version>30.1-jreversion>   
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 时,我们应该根据具体的需求和性能要求来选择合适的实现,并且充分利用其提供的视图和操作方法来简化代码和提高效率。

你可能感兴趣的:(工具,guava,java,spring,cloud,spring,boot,架构,jvm,面试)