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

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<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父类，可是假如想放入其他类型，就会编译报错：

所以，假如你想缓存目标，又不想做复杂的类型校验，那么运用方便的ClassToInstanceMap就能够了。

总结

本文介绍了guava中5种对Map的扩展数据结构，它们提供了十分有用的功用，能很大程度的简化咱们的代码。可是一起运用中也有不少需要避开的坑，例如修改相关的视图会对原始数据形成影响等等，详细的运用中咱们还需要谨慎一些。

那么，这次的共享就到这儿，我是Hydra，下期见。

作者简介，码农参上，一个热爱共享的大众号，风趣、深入、直接，与你聊聊技术。欢迎添加好友，进一步沟通。

本文正在参与「金石方案 . 瓜分6万现金大奖」

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

Table – 双键Map

1、获得key或value的调集

2、核算key对应的一切value的和

3、转化rowKey和columnKey

4、转为嵌套的Map

BiMap – 双向Map

1、回转后操作的影响

2、value不可重复

Multimap – 多值Map

1、获取值的调集

2、操作get后的调集

3、转化为Map

4、数量问题

RangeMap – 规模Map

ClassToInstanceMap – 实例Map

总结

相关文章

稀疏微调：彻底改变大语言模型的推理速度

一个门外汉对 ChatGPT 未来应用场景的畅享

如何在Proxmox VE 8上配置使用Mellanox网卡的OVS Hardware Offload

autojs的nodejs打包成品app的经验之谈

作者信息