共计 8765 个字符，预计需要花费 22 分钟才能阅读完成。
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(“Jan”,20);
workMap.put(“Feb”,28);
map.put(“Hydra”,workMap);
// 取出元素
Integer dayCount = map.get(“Hydra”).get(“Jan”);
复制代码
如果应用 Table 的话就很简略了，看一看简化后的代码：
Table<String,String,Integer> table= HashBasedTable.create();
// 寄存元素
table.put(“Hydra”, “Jan”, 20);
table.put(“Hydra”, “Feb”, 28);
table.put(“Trunks”, “Jan”, 28);
table.put(“Trunks”, “Feb”, 16);
// 取出元素
Integer dayCount = table.get(“Hydra”, “Feb”);
复制代码
咱们不须要再构建简单的双层 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 + ":" + 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()+","+cell.getColumnKey()+":"+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(“Hydra”,”Programmer”);
biMap.put(“Tony”,”IronMan”);
biMap.put(“Thanos”,”Titan”);
// 应用 key 获取 value
System.out.println(biMap.get(“Tony”));
BiMap<String, String> inverse = biMap.inverse();
// 应用 value 获取 key
System.out.println(inverse.get(“Titan”));
复制代码
执行后果，：
IronMan
Thanos
复制代码
看上去很实用是不是？然而应用中还有几个坑得避一下，上面一个个梳理。
1、反转后操作的影响
下面咱们用 inverse 办法反转了原来 BiMap 的键值映射，然而这个反转后的 BiMap 并不是一个新的对象，它实现了一种视图的关联，所以对反转后的 BiMap 执行的所有操作会作用于原先的 BiMap 上。
HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put(“Hydra”,”Programmer”);
biMap.put(“Tony”,”IronMan”);
biMap.put(“Thanos”,”Titan”);
BiMap<String, String> inverse = biMap.inverse();
inverse.put(“IronMan”,”Stark”);
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(“Tony”,”IronMan”);
biMap.put(“Stark”,”IronMan”);
复制代码
这样代码无奈失常完结，会抛出一个 IllegalArgumentException 异样：
如果你非想把新的 key 映射到已有的 value 上，那么也能够应用 forcePut 办法强制替换掉原有的 key：
HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put(“Tony”,”IronMan”);
biMap.forcePut(“Stark”,”IronMan”);
复制代码
打印一下替换后的 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(“day”,list);
复制代码
guava 中的 Multimap 提供了将一个键映射到多个值的模式，应用起来无需定义简单的内层汇合，能够像应用一般的 Map 一样应用它，定义及放入数据如下：
Multimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.put(“day”,1);
multimap.put(“day”,2);
multimap.put(“day”,8);
multimap.put(“month”,3);
复制代码
打印这个 Multimap 的内容，能够直观的看到每个 key 对应的都是一个汇合：
{month=[3], day=[1, 2, 8]}
复制代码
1、获取值的汇合
在下面的操作中，创立的一般 Multimap 的 get(key)办法将返回一个 Collection 类型的汇合：
Collection<Integer> day = multimap.get(“day”);
复制代码
如果在创立时指定为 ArrayListMultimap 类型，那么 get 办法将返回一个 List：
ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
List<Integer> day = multimap.get(“day”);
复制代码
同理，你还能够创立 HashMultimap、TreeMultimap 等类型的 Multimap。
Multimap 的 get 办法会返回一个非 null 的汇合，然而这个汇合的内容可能是空，看一下上面的例子：
List<Integer> day = multimap.get(“day”);
List<Integer> year = multimap.get(“year”);
System.out.println(day);
System.out.println(year);
复制代码
打印后果：
[1, 2, 8]
[]
复制代码
2、操作 get 后的汇合
和 BiMap 的应用相似，应用 get 办法返回的汇合也不是一个独立的对象，能够了解为汇合视图的关联，对这个新汇合的操作依然会作用于原始的 Multimap 上，看一下上面的例子：
ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.put(“day”,1);
multimap.put(“day”,2);
multimap.put(“day”,8);
multimap.put(“month”,3);
List<Integer> day = multimap.get(“day”);
List<Integer> month = multimap.get(“month”);
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+":"+map.get(key));}
map.get(“day”).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()+","+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 "fail";
else if (60<=score && score<=90)
return "satisfactory";
else if (90<score && score<=100)
return "excellent";
return null;}
复制代码
而 guava 中的 RangeMap 形容了一种从区间到特定值的映射关系，让咱们可能以更为优雅的办法来书写代码。上面用 RangeMap 革新下面的代码并进行测试：
RangeMap<Integer, String> rangeMap = TreeRangeMap.create();
rangeMap.put(Range.closedOpen(0,60),”fail”);
rangeMap.put(Range.closed(60,90),”satisfactory”);
rangeMap.put(Range.openClosed(90,100),”excellent”);
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(“Hydra”,18);
Dept dept=new Dept(“develop”,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(“Hydra”,18);
Dept dept=new Dept(“develop”,200);
map.put(User.class,user);
map.put(Dept.class,dept);
复制代码
那么，应用 ClassToInstanceMap 这种形式有什么益处呢？
首先，这里最显著的就是在取出对象时省去了简单的强制类型转换，防止了手动进行类型转换的谬误。其次，咱们能够看一下 ClassToInstanceMap 接口的定义，它是带有泛型的：
public interface ClassToInstanceMap 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 父类，然而如果想放入其余类型，就会编译报错：
所以，如果你想缓存对象，又不想做简单的类型校验，那么使用方便的 ClassToInstanceMap 就能够了。
总结
本文介绍了 guava 中 5 种对 Map 的扩大数据结构，它们提供了十分实用的性能，能很大水平的简化咱们的代码。然而同时应用中也有不少须要避开的坑，例如批改关联的视图会对原始数据造成影响等等，具体的应用中大家还须要审慎一些。