当前位置：网站首页>These map operations in guava have reduced my code by 50%
These map operations in guava have reduced my code by 50%
2022-06-24 21:56:00 【InfoQ】
Guava yes google Developed by the company Java Class library extension kit , It contains rich API, Covers the collection 、 cache 、 Concurrent 、I/O And so on . Use these API On the one hand, it can simplify our code , Make the code more elegant , On the other hand, it adds a lot jdk Features not available in , It can make our development more efficient .
today Hydra What I want to share with you is Guava Some information about
Map Operation , After using these functions , I have to say, it's really fragrant . First introduce dependent coordinates , Then start our formal experience ~
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1.1-jre</version>
</dependency>
Table - Double bond Map
java Medium
Map Only one is allowed
key And a
value There is , however guava Medium
Table Allows a
value There are two
key.
Table Two of them
key They are called
rowKey and
columnKey, That is, rows and columns .（ But I don't think it's very accurate to understand them as rows and columns , It might be more appropriate to think of it as two columns ）
Let's take a simple example , If you want to record the number of days an employee works every month . use java Medium common
Map If you implement it, you need two layers of nesting ：
Map<String,Map<String,Integer>> map=new HashMap<>();
// Store elements
Map<String,Integer> workMap=new HashMap<>();
workMap.put("Jan",20);
workMap.put("Feb",28);
map.put("Hydra",workMap);
// Take out the elements
Integer dayCount = map.get("Hydra").get("Jan");
If you use
Table It's easy , Take a look at the simplified code ：
Table<String,String,Integer> table= HashBasedTable.create();
// Store elements
table.put("Hydra", "Jan", 20);
table.put("Hydra", "Feb", 28);
table.put("Trunks", "Jan", 28);
table.put("Trunks", "Feb", 16);
// Take out the elements
Integer dayCount = table.get("Hydra", "Feb");
We don't need to build complex double layers
Map, Go straight to the first floor . In addition to the access of elements , Let's take a look at other practical operations .
1、 get key or value Set
//rowKey or columnKey Set
Set<String> rowKeys = table.rowKeySet();
Set<String> columnKeys = table.columnKeySet();
//value aggregate
Collection<Integer> values = table.values();
Print their results separately ,
key The collection of does not contain duplicate elements ,
value The set contains all elements without de duplication ：
[Hydra, Trunks]
[Jan, Feb]
[20, 28, 28, 16]
2、 Calculation key All corresponding value And
To count all
rowKey Corresponding
value Take the sum of ：
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);
}
Print the results ：
Hydra: 48
Trunks: 44
3、 transformation rowKey and columnKey
This operation can also be understood as the transpose of rows and columns , Call directly
Tables Static method of
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())
);
utilize
cellSet Method can get all the data rows , Print the results , You can see
row and
column There was a swap ：
Jan,Hydra:20
Feb,Hydra:28
Jan,Trunks:28
Feb,Trunks:16
4、 Turn to nested Map
We don't remember using it
Table The format in which the data is stored before , If you want to restore data to nested
Map The form of , Use
Table Of
rowMap or
columnMap Method can be implemented ：
Map<String, Map<String, Integer>> rowMap = table.rowMap();
Map<String, Map<String, Integer>> columnMap = table.columnMap();
View the converted format
Map The content in , Summarized by row and column respectively ：
{Hydra={Jan=20, Feb=28}, Trunks={Jan=28, Feb=16}}
{Jan={Hydra=20, Trunks=28}, Feb={Hydra=28, Trunks=16}}
BiMap - two-way Map
In general
Map in , If you want to be based on
value Find the corresponding
key, There's no easy way , Whether to use
for Loops or iterators , Need to traverse the whole
Map. To cycle
keySet For example ：
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;
}
and guava Medium
BiMap Provides a
key and
value Two way associated data structure , Let's start with a simple example ：
HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put("Hydra","Programmer");
biMap.put("Tony","IronMan");
biMap.put("Thanos","Titan");
// Use key obtain value
System.out.println(biMap.get("Tony"));
BiMap<String, String> inverse = biMap.inverse();
// Use value obtain key
System.out.println(inverse.get("Titan"));
Execution results ,：
IronMan
Thanos
It looks very practical, doesn't it ？ But there are still several pits to avoid in use , The following combs one by one .
1、 Effect of operation after reversal
Up here we use
inverse The method reverses the original
BiMap Key value mapping of , But after this reversal
BiMap Not a new object , It implements a view Association , So after the reversal
BiMap All operations performed will act on the original
BiMap On .
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);
Yes, after the reversal
BiMap After the content in has been modified , Take another look at the original
BiMap The content in ：
{Hydra=Programmer, Thanos=Titan, Stark=IronMan}
You can see , The original value is
IronMan The corresponding key is
Tony, Although not directly modified , But now the key becomes
Stark.
2、value Do not repeat
BiMap The bottom layer of inherited
Map, We know that
Map in
key It's not allowed to repeat , And two-way
BiMap in
key and
value It can be considered to be in an equivalent position , Therefore, restrictions are added on this basis ,
value No repetition is allowed . Take a look at the following code ：
HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put("Tony","IronMan");
biMap.put("Stark","IronMan");
In this way, the code cannot end normally , Will throw out a
IllegalArgumentException abnormal ：
If you have to put the new
key Map to existing
value On , You can also use
forcePut Method to force the replacement of the original
key：
HashBiMap<String, String> biMap = HashBiMap.create();
biMap.put("Tony","IronMan");
biMap.forcePut("Stark","IronMan");
Print the replaced
BiMap：
{Stark=IronMan}
By the way , because
BiMap Of
value It's not allowed to repeat , So it's
values Method returns no duplicate
Set, Not the ordinary
Collection：
Set<String> values = biMap.values();
Multimap - Multivalued Map
java Medium
Map Maintain a one-to-one relationship between key values , If you want to map a key to multiple values , Then you can only set the content of the value as a set , The simple implementation is as follows ：
Map<String, List<Integer>> map=new HashMap<>();
List<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
map.put("day",list);
guava Medium
Multimap Provides a form of mapping a key to multiple values , There is no need to define a complex inner set , It can be like using ordinary
Map Use it the same way , The definition and data are as follows ：
Multimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.put("day",1);
multimap.put("day",2);
multimap.put("day",8);
multimap.put("month",3);
Print this
Multimap The content of , You can intuitively see each
key Corresponding to a set ：
{month=[3], day=[1, 2, 8]}
1、 Get a collection of values
In the above operation , Create a normal
Multimap Of
get(key) Method will return a
Collection A collection of types ：
Collection<Integer> day = multimap.get("day");
If specified as
ArrayListMultimap type , that
get Method will return a
List：
ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
List<Integer> day = multimap.get("day");
Empathy , You can also create
HashMultimap、
TreeMultimap Etc
Multimap.
Multimap Of
get Method will return a non
null Set , But the contents of this collection may be empty , Take a look at the following example ：
List<Integer> day = multimap.get("day");
List<Integer> year = multimap.get("year");
System.out.println(day);
System.out.println(year);
Print the results ：
[1, 2, 8]
[]
2、 operation get After the collection
and
BiMap The use of is similar to , Use
get The collection returned by the method is not a separate object , It can be understood as the association of collection views , Operations on this new collection will still work on the original
Multimap On , Take a look at the following example ：
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);// This 0 It's a subscript
month.add(12);
System.out.println(multimap);
View modified results ：
{month=[3, 12], day=[2, 8]}
3、 Convert to Map
Use
asMap Method , Can be
Multimap Convert to
Map<K,Collection> In the form of , The same one
Map It can also be seen as an associated view , In this
Map The operation on will act on the original
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);
Execution results ：
month : [3]
day : [1, 2, 8]
{month=[3], day=[1, 2, 8, 20]}
4、 The question of quantity
Multimap There are also some confusing places in the use of the quantity in , Let's look at the following example ：
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());
}
Print the results ：
4
4
month,3
day,1
day,2
day,8
This is because
size() Method returns all
key To single
value Mapping , So the result is 4,
entries() The same way , The return is
key And single
value Set of key value pairs for . But it's
keySet What is saved in is different
key The number of , For example, the following line of code will print 2.
System.out.println(multimap.keySet().size());
Let's see how to convert it into
Map after , The quantity will change ：
Set<Map.Entry<String, Collection<Integer>>> entries = multimap.asMap().entrySet();
System.out.println(entries.size());
The result of the code run is 2, Because what it gets is
key To
Collection The mapping relation of .
RangeMap - Range Map
Let's look at an example , Suppose we want to classify test scores according to scores , Then there will be such ugly in the code
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;
}
and guava Medium
RangeMap A mapping relationship from interval to specific value is described , Let's write code in a more elegant way . The following is used
RangeMap Modify the above code and test it ：
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));
In the code above , We have created
[0,60) Left closed right open interval of 、
[60,90] The closed interval of 、
(90,100] Left open right closed interval of , And map to a value . Run result print ：
fail
satisfactory
satisfactory
excellent
Of course, we can also remove a space , The following code removes
[70,80] After this closed interval , Re execution
get The returned result is
null：
rangeMap.remove(Range.closed(70,80));
System.out.println(rangeMap.get(75));
ClassToInstanceMap - example Map
ClassToInstanceMap It's a special one
Map, Its key is
Class, And the value is this
Class The corresponding instance object . Let's start with a simple example , Use
putInstance Method into the object ：
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);
Use
getInstance Method to get the object ：
User user1 = instanceMap.getInstance(User.class);
System.out.println(user==user1);
The running results are printed
true, It shows that the object taken out is indeed the object we created and put in before .
You may wonder , If you just save objects , Use ordinary ones like the following
Map<Class,Object> It can also be realized ：
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);
that , Use
ClassToInstanceMap What are the benefits of this approach ？
First , The most obvious thing here is that the complex cast is omitted when taking out the object , Avoid manual type conversion errors . secondly , We can have a look
ClassToInstanceMap Definition of interface , It's generic ：
public interface ClassToInstanceMap<B> extends Map<Class<? extends B>, B>{...}
This generic type can also serve as a constraint on types ,
value Must conform to
key The corresponding type , Take a look at the following example ：
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);
This can be performed normally , because
HashMap and
TreeMap All integrated
Map Parent class , But if you want to put other types , It will compile and report errors ：
therefore , If you want to cache objects , I don't want to do complex type checking , So easy to use
ClassToInstanceMap That's all right. .
summary
This paper introduces guava in 5 Seed pair
Map The extended data structure of , They provide very practical functions , Can greatly simplify our code . But at the same time, there are many pits to avoid , For example, modifying the associated view will affect the original data, and so on , We need to be cautious in specific use .
that , This sharing is here , I am a Hydra, See you next time .
Author's brief introduction , Manongshen , An official account of sharing love , Interesting 、 thorough 、 direct , Talk to you about technology . Welcome to add friends , Further communication .
边栏推荐
- leetcode1720_2021-10-14
- 排查到解决问题的过程：浏览器突然无法访问网页，错误代码：0x80004005，最终定位：“电脑打开热点，电脑就不能上网了”
- 基于ASP.NET开发的固定资产管理系统源码 企业固定资产管理系统源码
- Data link layer & some other protocols or technologies
- 网络层 ＆＆ IP
- 01---两列波在相遇处发生干涉的条件
- 如何化解35岁危机？华为云数据库首席架构师20年技术经验分享
- 【吴恩达笔记】机器学习基础
- Introduce the overall process of bootloader, PM, kernel and system startup
- 基于kruskal的最小生成树
猜你喜欢
![[精选] 多账号统一登录，你如何设计？](/img/df/9b4fc11a6971ebe8162ae84250a782.png)
[精选] 多账号统一登录，你如何设计？
![[camera Foundation (I)] working principle and overall structure of camera](/img/5d/c29d636a90d01e5c3852df2a0dd833.png)
[camera Foundation (I)] working principle and overall structure of camera
滤波数据分析
Réduire le PIP à la version spécifiée (mettre à jour le PIP avec pycharm avant de le réduire à la version originale)
多线程收尾
Multi task model of recommended model: esmm, MMOE
leetcode-201_2021_10_17
应用实践 | 海量数据，秒级分析！Flink+Doris 构建实时数仓方案
煮茶论英雄！福建省发改委、市营商办领导一行莅临育润大健康事业部交流指导
机器学习:线性回归
随机推荐
C language - keyword 1
TypeScript快速入门
基于ASP.NET开发的固定资产管理系统源码 企业固定资产管理系统源码
ST表+二分
Multi task model of recommended model: esmm, MMOE
火狐拖放后，总会默认打开百度搜索，如果是图片，则会打开图片。
Visit Amazon memorydb and build your own redis memory database
PKI notes
dp问题集
Network layer & IP
想当测试Leader，这6项技能你会吗？
LeetCode-513. Find the value in the lower left corner of the tree
多线程收尾
leetcode1863_ 2021-10-14
【吴恩达笔记】卷积神经网络
Kubernetes 集群中流量暴露的几种方案
手动事务的几个类
[camera Foundation (II)] camera driving principle and Development & v4l2 subsystem driving architecture
leetcode-201_ 2021_ 10_ seventeen
队列实现原理和应用