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的擴充套件資料結構，它們提供了非常實用的功能，能很大程度的簡化我們的程式碼。但是同時使用中也有不少需要避開的坑，例如修改關聯的檢視會對原始資料造成影響等等，具體的使用中大家還需要謹慎一些。