引入依賴
<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就可以了，
轉載來源：https://mp.weixin.qq.com/s/LjtzKXIhGFEWQ5xzCoYPww
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/487415.html
標籤：Java