Guava系列之新的集合类型

￡神魔★判官ぃ 2023-02-17 02:28 19阅读 0赞

> Guava中新增加了一些集合类型，是对JDK集合类型的补充，使开发者更方便使用集合类型来实现业务功能

#### Multiset ####

首先我们来看一下日常研发中常用到的一个场景，统计一个list中每个元素出现的次数，我们大概会这样写：

List<String> list = new ArrayList<String>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    list.add("b");
    list.add("b");
    Map<String,Integer> countMap = new HashMap<String,Integer>();
    for(String str : list){ 
        if(countMap.get(str) != null){ 
            countMap.put(str,countMap.get(str) + 1);
        } else { 
            countMap.put(str,1);
        }
    }

*  首先定义一个list，然后往里面新增若干个元素
 *  定义一个Map，遍历list将每个元素出现的次数记录在map里面

显然这样的写法，看起来还是挺笨拙的

Guava提供了Multiset，虽然名字带有Set，但它可以添加重复的元素

Multiset可以看成是ArrayList和Map的结合体

*  Multiset是没有元素顺序限制的ArrayList
 *  Multiset提供了键为元素，值为计数的Map

下面我们来看一下Multiset的实际用法

//通过create()方法创建
            Multiset<String> multiset = HashMultiset.create();
            //可直接添加元素
            multiset.add("a");
            multiset.add("b");
            multiset.add("c");
            multiset.add("c");
            multiset.add("c");
            List<String> list = new ArrayList<String>();
            list.add("xx");
            list.add("yy");
            list.add("zz");
            //也可用addAll方法添加集合进来
            multiset.addAll(list);
    
            //获取元素"c"的计数
            System.out.println(multiset.count("c"));
    
            //返回去重后的元素set集合
            Set<String> set = multiset.elementSet();
    
            //multiset所有元素的个数
            System.out.println("multiset.size():" + multiset.size());
            //multiset去重后的元素个数
            System.out.println("elementSet().size():" + multiset.elementSet().size());
    
            //元素迭代
           Iterator<String> it = multiset.iterator();
            while(it.hasNext()){ 
                System.out.println(it.next());
            }
    
            //可以通过设置元素的计数，来批量的添加元素，当然能加也能减
            multiset.setCount("c",5);
    
            //将元素的计数设为0，就相当于移除所有的"c"元素
            multiset.setCount("c",0);
    
            //移除一个元素
            multiset.remove("c");
    
            //移除两个"c"元素
            multiset.remove("c",2);

可以看出来，Multiset包含了基本的集合操作外，还有一些特有的操作，比如setCount()、按个数remove()

Guava提供了多种Multiset的实现，大致对应JDK中Map的各种实现：

<table> 
 <thead> 
  <tr> 
   <th>Map</th> 
   <th>对应的Multiset</th> 
   <th>是否支持null元素</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>HashMap</td> 
   <td>HashMultiset</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>TreeMap</td> 
   <td>TreeMultiset</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>LinkedHashMap</td> 
   <td>LinkedHashMultiset</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>ConcurrentHashMap</td> 
   <td>ConcurrentHashMultiset</td> 
   <td>否</td> 
  </tr> 
  <tr> 
   <td>ImmutableMap</td> 
   <td>ImmutableMultiset</td> 
   <td>否</td> 
  </tr> 
 </tbody> 
</table>

#### SortedMultiset ####

SortedMultiset支持高效的获取指定范围的子集

SortedMultiset<String> sortedMultiset = TreeMultiset.create();
    sortedMultiset.setCount("c",5);
    sortedMultiset.setCount("a",3);
    sortedMultiset.setCount("b",2);
    //获取第一个元素
    sortedMultiset.firstEntry().getElement();
    //获了最后一个元素
    sortedMultiset.lastEntry().getElement();
    //获取子集
    SortedMultiset<String> subMultiset = sortedMultiset.subMultiset("a", BoundType.OPEN,"b",BoundType.CLOSED);

需要注意，SortedMultiset默认是排好序的，是按元素来进行排序的而不是元素的个数

#### Multimap ####

在JDK中Map是存储Key-value型数据结构的，并且Key相同时会被覆盖掉,比如

Map<String,String> map = new HashMap<String,String>();
    map.put("key","value1");
    map.put("key","value2");

最终map里只会存key->value2的值

在很多时候，我们需要一个key对应多个值，在JDK中只能以类似于Map<K,List>这种形式来表达,操作起来很不方便

Guava为我们提供了Multimap，可以用来做一个Key映射多个值的操作

Multimap multimap = ArrayListMultimap.create();
    //新增元素,直接put
    multimap.put("a","123");
    multimap.put("a","111");
    multimap.put("b","456");
    multimap.put("d","789");
    
    Multimap multimap1 = LinkedListMultimap.create();
    multimap1.put("a","a1_value");
    multimap1.put("k2","k2_value");
    //使用putAll方法可以添加一个multimap，这个跟JDK中的putAll一样，而且key相同时会进行合并
    multimap.putAll(multimap1);
    
    List<String> list = Lists.newArrayList("a_value1","a_value2","a_value3");
    //还可以指定key进行批量添加元素，注意此处是追加到key中，不是替换
    multimap.putAll("a",list);
    
    //multimap中的所有键值对，重复的算多个
    System.out.println(multimap.size());
    //key的个数
    System.out.println(multimap.keySet().size());
    
    //移除指定key的指定value
    multimap.remove("a","111");
    System.out.println(multimap);
    //移除整个key的所有value
    multimap.removeAll("a");
    System.out.println(multimap);
    
    
    //替换指定key的value
    multimap.replaceValues("b",Lists.newArrayList("b1_value","b2_value"));
    
    //是否包含指定的key
    System.out.println(multimap.containsKey("d"));
    //是否包含指定的键值对
    System.out.println(multimap.containsEntry("d","789"));
    //获取multimap中所有的value
    System.out.println(multimap.values());
    //返回Multiset
    System.out.println(multimap.keys());
    //返回Map类型
    Map<String,List<String>> map = multimap.asMap();
    
    //清空整个集合
    multimap.clear();
    
    System.out.println(multimap);

**Multimap的各种实现**

<table> 
 <thead> 
  <tr> 
   <th>实现</th> 
   <th>键行为类似</th> 
   <th>值行为类似</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ArrayListMultimap</td> 
   <td>HashMap</td> 
   <td>ArrayList</td> 
  </tr> 
  <tr> 
   <td>HashMultimap</td> 
   <td>HashMap</td> 
   <td>HashSet</td> 
  </tr> 
  <tr> 
   <td>LinkedListMultimap</td> 
   <td>LinkedHashMap</td> 
   <td>LinkedList</td> 
  </tr> 
  <tr> 
   <td>LinkedHashMultimap</td> 
   <td>LinkedHashMap</td> 
   <td>LinkedHashMap</td> 
  </tr> 
  <tr> 
   <td>TreeMultimap</td> 
   <td>TreeMap</td> 
   <td>TreeSet</td> 
  </tr> 
  <tr> 
   <td>ImmutableListMultimap</td> 
   <td>ImmutableMap</td> 
   <td>ImmutableList</td> 
  </tr> 
  <tr> 
   <td>ImmutableSetMultimap</td> 
   <td>ImmutableMap</td> 
   <td>ImmutableSet</td> 
  </tr> 
 </tbody> 
</table>

#### BiMap ####

在JDK中，如果我们要维护一个双向Map，需要定义两个Map来存储，并且两个要同时进行变更

Map<String,String> map1 = Maps.newHashMap();
    Map<String,String> map2 = Maps.newHashMap();
    map1.put("Hello","Kai");
    map2.put("Kai","Hello");

Guava提供了BiMap，它是一种特殊的Map，可以实现键值的反转

public static void main(String[] args){ 
            BiMap biMap = HashBiMap.create();
            biMap.put("a","123");
            System.out.println(biMap);
            //对键值对进行反转
            System.out.println(biMap.inverse());
    
            //试图将一个key映射到已经存在的值上，会抛异常
            biMap.put("b","123");
    
            //强值将一个key映射到已经存在的值上，会将原来的key覆盖掉
            biMap.forcePut("b","123");
            System.out.println(biMap);
    
        }

可以看出，因为BiMap要支持反转，所以它的key和value都必须是唯一的，要不然反转过来就存在一对多的情况

**BiMap的各种实现**

<table> 
 <thead> 
  <tr> 
   <th>键–值实现</th> 
   <th>值–键实现</th> 
   <th>对应的BiMap实现</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>HashMap</td> 
   <td>HashMap</td> 
   <td>HashBiMap</td> 
  </tr> 
  <tr> 
   <td>ImmutableMap</td> 
   <td>ImmutableMap</td> 
   <td>ImmutableBiMap</td> 
  </tr> 
  <tr> 
   <td>EnumMap</td> 
   <td>EnumMap</td> 
   <td>EnumBiMap</td> 
  </tr> 
  <tr> 
   <td>EnumMap</td> 
   <td>EnumMap</td> 
   <td>EnumHashBiMap</td> 
  </tr> 
 </tbody> 
</table>

#### Table ####

在JDK中当需要做key映射到Key-value对时，你需要这样写Map<K,Map<K,V>>,这种写法同样不够友好，同时也不便维护

这实际上就是一个表格的行、列、值的结构，Guava里面提供了表格来解决这种场景

//创建row,column,value结构的table
    Table<String,String,Integer> table = HashBasedTable.create();
    table.put("a1","c1",23);
    table.put("a1","c2",77);
    table.put("a2","c2",44);
    //通过rowKey获取columnKey->value的映射关系
    System.out.println(table.row("a1"));
    //通过columnKey获取rowKey ->value的映射关系
    System.out.println(table.column("c2"));

**Table有如下几种实现：**

*  HashBasedTable：本质上用HashMap<R, HashMap<C, V>>实现；
 *  TreeBasedTable：本质上用TreeMap<R, TreeMap<C,V>>实现；
 *  ImmutableTable：本质上用ImmutableMap<R, ImmutableMap<C, V>>实现；注：ImmutableTable对稀疏或密集的数据集都有优化。
 *  ArrayTable：要求在构造时就指定行和列的大小，本质上由一个二维数组实现，以提升访问速度和密集Table的内存利用率。ArrayTable与其他Table的工作原理有点不同，请参见Javadoc了解详情。

#### ClassToInstanceMap ####

ClassToInstanceMap是一种特殊的Map：它的键是类型，而值是符合键所指类型的对象

ClassToInstanceMap<Number> numberDefaults= MutableClassToInstanceMap.create();
    numberDefaults.putInstance(Integer.class,6);

还有RangeSet、RangeMap平时用的比较少，大家有需要可以去Guava官网上了解一下  
https://github.com/google/guava/wiki/NewCollectionTypesExplained

> 如果感觉对你有些帮忙，想跟我一起学习，坚信技术改变世界，请关注Java天堂公众号，我会定期分享自己的学习成果，第一时间推送给你

![在这里插入图片描述][20200528221140804.jpg_pic_center]

[20200528221140804.jpg_pic_center]: https://img-blog.csdnimg.cn/20200528221140804.jpg#pic_center