当前位置：网站首页>Guava中这些Map的骚操作，让我的代码量减少了50%

Guava中这些Map的骚操作，让我的代码量减少了50%

2022-06-24 19:28:00 【InfoQ】

Guava是google公司开发的一款Java类库扩展工具包，内含了丰富的API，涵盖了集合、缓存、并发、I/O等多个方面。使用这些API一方面可以简化我们代码，使代码更为优雅，另一方面它补充了很多jdk中没有的功能，能让我们开发中更为高效。

今天Hydra要给大家分享的就是Guava中封装的一些关于

Map

的骚操作，在使用了这些功能后，不得不说一句真香。先引入依赖坐标，然后开始我们的正式体验吧~

<dependency>
 <groupId>com.google.guava</groupId>
 <artifactId>guava</artifactId>
 <version>30.1.1-jre</version>
</dependency>

Table - 双键Map

java中的

Map

只允许有一个

key

和一个

value

存在，但是guava中的

Table

允许一个

value

存在两个

key

。

Table

中的两个

key

分别被称为

rowKey

和

columnKey

，也就是行和列。（但是个人感觉将它们理解为行和列并不是很准确，看作两列的话可能会更加合适一些）

举一个简单的例子，假如要记录员工每个月工作的天数。用java中普通的

Map

实现的话就需要两层嵌套：

Map<String,Map<String,Integer>> map=new HashMap<>();
//存放元素
Map<String,Integer> workMap=new HashMap<>();
workMap.put(&quot;Jan&quot;,20);
workMap.put(&quot;Feb&quot;,28);
map.put(&quot;Hydra&quot;,workMap);

//取出元素
Integer dayCount = map.get(&quot;Hydra&quot;).get(&quot;Jan&quot;);

如果使用

Table

的话就很简单了，看一看简化后的代码：

Table<String,String,Integer> table= HashBasedTable.create();
//存放元素
table.put(&quot;Hydra&quot;, &quot;Jan&quot;, 20);
table.put(&quot;Hydra&quot;, &quot;Feb&quot;, 28);

table.put(&quot;Trunks&quot;, &quot;Jan&quot;, 28);
table.put(&quot;Trunks&quot;, &quot;Feb&quot;, 16);

//取出元素
Integer dayCount = table.get(&quot;Hydra&quot;, &quot;Feb&quot;);

我们不需要再构建复杂的双层

Map

，直接一层搞定。除了元素的存取外，下面再看看其他的实用操作。

1、获得key或value的集合

//rowKey或columnKey的集合
Set<String> rowKeys = table.rowKeySet();
Set<String> columnKeys = table.columnKeySet();

//value集合
Collection<Integer> values = table.values();

分别打印它们的结果，

key

的集合是不包含重复元素的，

value

集合则包含了所有元素并没有去重：

[Hydra, Trunks]
[Jan, Feb]
[20, 28, 28, 16]

2、计算key对应的所有value的和

以统计所有

rowKey

对应的

value

之和为例：

for (String key : table.rowKeySet()) {
 Set<Map.Entry<String, Integer>> rows = table.row(key).entrySet();
 int total = 0;
 for (Map.Entry<String, Integer> row : rows) {
 total += row.getValue();
 }
 System.out.println(key + &quot;: &quot; + total);
}

打印结果：

Hydra: 48
Trunks: 44

3、转换rowKey和columnKey

这一操作也可以理解为行和列的转置，直接调用

Tables

的静态方法

transpose

：

Table<String, String, Integer> table2 = Tables.transpose(table);
Set<Table.Cell<String, String, Integer>> cells = table2.cellSet();
cells.forEach(cell->
 System.out.println(cell.getRowKey()+&quot;,&quot;+cell.getColumnKey()+&quot;:&quot;+cell.getValue())
);

利用

cellSet

方法可以得到所有的数据行，打印结果，可以看到

row

和

column

发生了互换：

Jan,Hydra:20
Feb,Hydra:28
Jan,Trunks:28
Feb,Trunks:16

4、转为嵌套的Map

还记得我们在没有使用

Table

前存储数据的格式吗，如果想要将数据还原成嵌套

Map

的那种形式，使用

Table

的

rowMap

或

columnMap

方法就可以实现了：

Map<String, Map<String, Integer>> rowMap = table.rowMap();
Map<String, Map<String, Integer>> columnMap = table.columnMap();

查看转换格式后的

Map

中的内容，分别按照行和列进行了汇总：

{Hydra={Jan=20, Feb=28}, Trunks={Jan=28, Feb=16}}
{Jan={Hydra=20, Trunks=28}, Feb={Hydra=28, Trunks=16}}

BiMap - 双向Map

在普通

Map

中，如果要想根据

value

查找对应的

key

，没什么简便的办法，无论是使用

for

循环还是迭代器，都需要遍历整个

Map

。以循环

keySet

的方式为例：

public List<String> findKey(Map<String, String> map, String val){
 List<String> keys=new ArrayList<>();
 for (String key : map.keySet()) {
 if (map.get(key).equals(val))
 keys.add(key);
 }
 return keys;
}

而guava中的

BiMap

提供了一种

key

和

value

双向关联的数据结构，先看一个简单的例子：

HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put(&quot;Hydra&quot;,&quot;Programmer&quot;);
biMap.put(&quot;Tony&quot;,&quot;IronMan&quot;);
biMap.put(&quot;Thanos&quot;,&quot;Titan&quot;);
//使用key获取value
System.out.println(biMap.get(&quot;Tony&quot;));

BiMap<String, String> inverse = biMap.inverse();
//使用value获取key
System.out.println(inverse.get(&quot;Titan&quot;));

执行结果，：

IronMan
Thanos

看上去很实用是不是？但是使用中还有几个坑得避一下，下面一个个梳理。

1、反转后操作的影响

上面我们用

inverse

方法反转了原来

BiMap

的键值映射，但是这个反转后的

BiMap

并不是一个新的对象，它实现了一种视图的关联，所以对反转后的

BiMap

执行的所有操作会作用于原先的

BiMap

上。

HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put(&quot;Hydra&quot;,&quot;Programmer&quot;);
biMap.put(&quot;Tony&quot;,&quot;IronMan&quot;);
biMap.put(&quot;Thanos&quot;,&quot;Titan&quot;);
BiMap<String, String> inverse = biMap.inverse();

inverse.put(&quot;IronMan&quot;,&quot;Stark&quot;);
System.out.println(biMap);

对反转后的

BiMap

中的内容进行了修改后，再看一下原先

BiMap

中的内容：

{Hydra=Programmer, Thanos=Titan, Stark=IronMan}

可以看到，原先值为

IronMan

时对应的键是

Tony

，虽然没有直接修改，但是现在键变成了

Stark

。

2、value不可重复

BiMap

的底层继承了

Map

，我们知道在

Map

中

key

是不允许重复的，而双向的

BiMap

中

key

和

value

可以认为处于等价地位，因此在这个基础上加了限制，

value

也是不允许重复的。看一下下面的代码：

HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put(&quot;Tony&quot;,&quot;IronMan&quot;);
biMap.put(&quot;Stark&quot;,&quot;IronMan&quot;);

这样代码无法正常结束，会抛出一个

IllegalArgumentException

异常：

如果你非想把新的

key

映射到已有的

value

上，那么也可以使用

forcePut

方法强制替换掉原有的

key

：

HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put(&quot;Tony&quot;,&quot;IronMan&quot;);
biMap.forcePut(&quot;Stark&quot;,&quot;IronMan&quot;);

打印一下替换后的

BiMap

：

{Stark=IronMan}

顺带多说一句，由于

BiMap

的

value

是不允许重复的，因此它的

values

方法返回的是没有重复的

Set

，而不是普通

Collection

：

Set<String> values = biMap.values();

Multimap - 多值Map

java中的

Map

维护的是键值一对一的关系，如果要将一个键映射到多个值上，那么就只能把值的内容设为集合形式，简单实现如下：

Map<String, List<Integer>> map=new HashMap<>();
List<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
map.put(&quot;day&quot;,list);

guava中的

Multimap

提供了将一个键映射到多个值的形式，使用起来无需定义复杂的内层集合，可以像使用普通的

Map

一样使用它，定义及放入数据如下：

Multimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.put(&quot;day&quot;,1);
multimap.put(&quot;day&quot;,2);
multimap.put(&quot;day&quot;,8);
multimap.put(&quot;month&quot;,3);

打印这个

Multimap

的内容，可以直观的看到每个

key

对应的都是一个集合：

{month=[3], day=[1, 2, 8]}

1、获取值的集合

在上面的操作中，创建的普通

Multimap

的

get(key)

方法将返回一个

Collection

类型的集合：

Collection<Integer> day = multimap.get(&quot;day&quot;);

如果在创建时指定为

ArrayListMultimap

类型，那么

get

方法将返回一个

List

：

ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
List<Integer> day = multimap.get(&quot;day&quot;);

同理，你还可以创建

HashMultimap

、

TreeMultimap

等类型的

Multimap

。

Multimap

的

get

方法会返回一个非

null

的集合，但是这个集合的内容可能是空，看一下下面的例子：

List<Integer> day = multimap.get(&quot;day&quot;);
List<Integer> year = multimap.get(&quot;year&quot;);
System.out.println(day);
System.out.println(year);

打印结果：

[1, 2, 8]
[]

2、操作get后的集合

和

BiMap

的使用类似，使用

get

方法返回的集合也不是一个独立的对象，可以理解为集合视图的关联，对这个新集合的操作仍然会作用于原始的

Multimap

上，看一下下面的例子：

ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.put(&quot;day&quot;,1);
multimap.put(&quot;day&quot;,2);
multimap.put(&quot;day&quot;,8);
multimap.put(&quot;month&quot;,3);

List<Integer> day = multimap.get(&quot;day&quot;);
List<Integer> month = multimap.get(&quot;month&quot;);

day.remove(0);//这个0是下标
month.add(12);
System.out.println(multimap);

查看修改后的结果：

{month=[3, 12], day=[2, 8]}

3、转换为Map

使用

asMap

方法，可以将

Multimap

转换为

Map<K,Collection>

的形式，同样这个

Map

也可以看做一个关联的视图，在这个

Map

上的操作会作用于原始的

Multimap

。

Map<String, Collection<Integer>> map = multimap.asMap();
for (String key : map.keySet()) {
 System.out.println(key+&quot; : &quot;+map.get(key));
}
map.get(&quot;day&quot;).add(20);
System.out.println(multimap);

执行结果：

month : [3]
day : [1, 2, 8]
{month=[3], day=[1, 2, 8, 20]}

4、数量问题

Multimap

中的数量在使用中也有些容易混淆的地方，先看下面的例子：

System.out.println(multimap.size());
System.out.println(multimap.entries().size());
for (Map.Entry<String, Integer> entry : multimap.entries()) {
 System.out.println(entry.getKey()+&quot;,&quot;+entry.getValue());
}

打印结果：

4
4
month,3
day,1
day,2
day,8

这是因为

size()

方法返回的是所有

key

到单个

value

的映射，因此结果为4，

entries()

方法同理，返回的是

key

和单个

value

的键值对集合。但是它的

keySet

中保存的是不同的

key

的个数，例如下面这行代码打印的结果就会是2。

System.out.println(multimap.keySet().size());

再看看将它转换为

Map

后，数量则会发生变化：

Set<Map.Entry<String, Collection<Integer>>> entries = multimap.asMap().entrySet();
System.out.println(entries.size());

代码运行结果是2，因为它得到的是

key

到

Collection

的映射关系。

RangeMap - 范围Map

先看一个例子，假设我们要根据分数对考试成绩进行分类，那么代码中就会出现这样丑陋的

if-else

：

public static String getRank(int score){
 if (0<=score && score<60)
 return &quot;fail&quot;;
 else if (60<=score && score<=90)
 return &quot;satisfactory&quot;;
 else if (90<score && score<=100)
 return &quot;excellent&quot;;
 return null;
}

而guava中的

RangeMap

描述了一种从区间到特定值的映射关系，让我们能够以更为优雅的方法来书写代码。下面用

RangeMap

改造上面的代码并进行测试：

RangeMap<Integer, String> rangeMap = TreeRangeMap.create();
rangeMap.put(Range.closedOpen(0,60),&quot;fail&quot;);
rangeMap.put(Range.closed(60,90),&quot;satisfactory&quot;);
rangeMap.put(Range.openClosed(90,100),&quot;excellent&quot;);

System.out.println(rangeMap.get(59));
System.out.println(rangeMap.get(60));
System.out.println(rangeMap.get(90));
System.out.println(rangeMap.get(91));

在上面的代码中，先后创建了

[0,60)

的左闭右开区间、

[60,90]

的闭区间、

(90,100]

的左开右闭区间，并分别映射到某个值上。运行结果打印：

fail
satisfactory
satisfactory
excellent

当然我们也可以移除一段空间，下面的代码移除了

[70,80]

这一闭区间后，再次执行

get

时返回结果为

null

：

rangeMap.remove(Range.closed(70,80));
System.out.println(rangeMap.get(75));

ClassToInstanceMap - 实例Map

ClassToInstanceMap

是一个比较特殊的

Map

，它的键是

Class

，而值是这个

Class

对应的实例对象。先看一个简单使用的例子，使用

putInstance

方法存入对象：

ClassToInstanceMap<Object> instanceMap = MutableClassToInstanceMap.create();
User user=new User(&quot;Hydra&quot;,18);
Dept dept=new Dept(&quot;develop&quot;,200);

instanceMap.putInstance(User.class,user);
instanceMap.putInstance(Dept.class,dept);

使用

getInstance

方法取出对象：

User user1 = instanceMap.getInstance(User.class);
System.out.println(user==user1);

运行结果打印了

true

，说明了取出的确实是我们之前创建并放入的那个对象。

大家可能会疑问，如果只是存对象的话，像下面这样用普通的

Map<Class,Object>

也可以实现：

Map<Class,Object> map=new HashMap<>();
User user=new User(&quot;Hydra&quot;,18);
Dept dept=new Dept(&quot;develop&quot;,200);
map.put(User.class,user);
map.put(Dept.class,dept);

那么，使用

ClassToInstanceMap

这种方式有什么好处呢？

首先，这里最明显的就是在取出对象时省去了复杂的强制类型转换，避免了手动进行类型转换的错误。其次，我们可以看一下

ClassToInstanceMap

接口的定义，它是带有泛型的：

public interface ClassToInstanceMap<B> extends Map<Class<? extends B>, B>{...}

这个泛型同样可以起到对类型进行约束的作用，

value

要符合

key

所对应的类型，再看看下面的例子：

ClassToInstanceMap<Map> instanceMap = MutableClassToInstanceMap.create();
HashMap<String, Object> hashMap = new HashMap<>();
TreeMap<String, Object> treeMap = new TreeMap<>();
ArrayList<Object> list = new ArrayList<>();

instanceMap.putInstance(HashMap.class,hashMap);
instanceMap.putInstance(TreeMap.class,treeMap);

这样是可以正常执行的，因为

HashMap

和

TreeMap

都集成了

Map

父类，但是如果想放入其他类型，就会编译报错：