我們提一個需求：給定一個 List<String>

，統計每個元素出現的所有位置。

比如，給定 list： ["a","b","c","d","f","g"] ，那麼應該返回：

a : [0] b : [1,2] c : [3,4,5] d : [6,7,8] f : [9,10] g : [11]

很明顯，我們很適合使用 Map 來完成這件事情：

public static Map<String,List<Integer>> getElementPositions(List<String> list) {
  Map<String,List<Integer>> positionsMap = new HashMap<>();
  for (int i = 0; i < list.size(); i++) {
    String str = list.get(i);
    List<Integer> positions = positionsMap.get(str);
    if (positions == null) { // 如果 positionsMap 還不存在 str 這個鍵及其對應的 List<Integer>
      positions = new ArrayList<>(1);
      positionsMap.put(str,positions); // 將 str 及其對應的 positions 放入 positionsMap
    }
    positions.add(i); // 將索引加入 str 相關聯的 List<Integer> 中
  }
  return positionsMap;
}
public static void main(String[] args) throws Exception {
  List<String> list = Arrays.asList("a","g");
  System.out.println("使用 Java8 之前的 API：");
  Map<String,List<Integer>> elementPositions = getElementPositions(list);
  System.out.println(elementPositions);
}

執行結果：

Java8 時， Map<K,V> 介面添加了一個新的方法， putIfAbsent(K key,V value) ，功能是： 如果當前 Map 不存在鍵 key 或者該 key 關聯的值為 null ，那麼就執行 put(key,value) ；否則，便不執行 put 操作。該方法等價於如下程式碼：

（題外話： putIfAbsent 方法與 put 方法一樣，返回的是方法呼叫之前與引數 key 相關聯的 value ）

使用 putIfAbsent 修改 getElementPositions 方法：

public static Map<String,List<Integer>> positionsMap = new HashMap<>();
  for (int i = 0; i < list.size(); i++) {
    String str = list.get(i);
    positionsMap.putIfAbsent(str,new ArrayList<>(1)); // 如果 positionsMap 不存在鍵 str 或者 str 關聯的 List<Integer> 為 null，那麼就會進行 put；否則不執行 put
    positionsMap.get(str).add(i);
  }
  return positionsMap;
}
public static void main(String[] args) throws Exception {
  List<String> list = Arrays.asList("a","g");
  System.out.println("使用 putIfAbsent：");
  Map<String,List<Integer>> elementPositions = getElementPositions(list);
  System.out.println(elementPositions);
}

執行結果：

可以看到使用 putIfAbsent 之後的 getElementPositions 簡潔了一點，那還能更簡潔嗎？

檢視 Map 介面的方法，可以發現在 JDK1.8 時，還添加了如下兩個方法：

檢視 compute 方法的 API 文件，可以發現 compute 方法與如下程式碼等價

V oldValue = map.get(key);
 V newValue = remappingFunction.apply(key,oldValue);
 if (oldValue != null ) {
  if (newValue != null)
    map.put(key,newValue);
  else
    map.remove(key);
 } else { // 即 原來的 key 不存在 Map 中或該 key 關聯的 value 為 null
  if (newValue != null)
    map.put(key,newValue);
  else
    return null;
 }

compute 方法和原來 put 方法的區別在於：

put(K key,V value) 方法，如果 key 在 Map 中不存在，那麼直接加入；如果已經存在，那麼使用新的 value 替換舊的 value ；

而 compute(K key,BiFunction remappingFunction) 方法可以通過一個 BiFunction 來計算出新的 value ， BiFunction 的引數為舊的 key 和 value ，返回計算出新的 value —— 與 put 方法不同， compute 方法返回的會是最新的與 key 相關聯的 value ，而不是舊的 value 。 所以可以使用 compute 方法改寫 getElementPositions 如下：

public static Map<String,List<Integer>> positionsMap = new HashMap<>();
  for (int i = 0; i < list.size(); i++) {
    positionsMap.compute(list.get(i),(k,v) -> v == null ? new ArrayList<>(1) : v).add(i);
  }
  return positionsMap;
}
public static void main(String[] args) throws Exception {
  List<String> list = Arrays.asList("a","g");
  System.out.println("使用 compute：");
  Map<String,List<Integer>> elementPositions = getElementPositions(list);
  System.out.println(elementPositions);
}

(k,v) -> v == null ? new ArrayList<>(1) : v 即 如果當前的 value 為 null ，那麼 該 BiFunction 的返回值為 new ArrayList<>(1) ；如果不為 null ，那麼返回值便是本身。而且因為 compute 方法會返回新的 value —— 此時便是與 list.get(i) （key） 相關聯的 ArrayList —— 所以我們可以直接呼叫其 add 方法。

執行結果：

很棒~ 還能更簡潔嗎？ 我們再看看 computeIfAbsent 方法： computeIfAbsent 和 compute 的關係，就類似於 putIfAbsent 和 put 的關係： computeIfAbsent 在 key 不在 Map 中或者與 key 相關聯的 value 為 null 時，才執行通過函式計算新 value 的操作，否則不執行； computeIfAbsent 的返回值也是與 key 相關聯的最新的 value 。其預設實現如下：

與 compute 不同， computeIfAbsent 接受的函式操作是 Function 而不是 BiFunction —— 這很好理解， computeIfAbsent 只在 ke y 不在 Map 中或者與 key 相關聯的 value 為 null 時才執行函式操作，那麼顯然此時與 key 相關的 value 為 null ，所以 computeIfAbsent 只接受 Function 作為引數即可 —— 該 Function 可以使用 key 作為引數計算出新的 value 。使用 computeIfAbsent 改寫 getElementPositions ：

public static Map<String,List<Integer>> positionsMap = new HashMap<>();

  for (int i = 0; i < list.size(); i++) {
    positionsMap.computeIfAbsent(list.get(i),k -> new ArrayList<>(1)).add(i);
  }
  return positionsMap;
}
public static void main(String[] args) throws Exception {
  List<String> list = Arrays.asList("a","g");
  System.out.println("使用 computeIfAbsent：");
  Map<String,List<Integer>> elementPositions = getElementPositions(list);
  System.out.println(elementPositions);
}

執行結果：

事實上，本文使用 putIfAbsent 時是存在問題的， positionsMap.putIfAbsent(str,new ArrayList<>(1)) ; 這句程式碼每次呼叫時都會產生一個臨時的 ArrayList —— 當遍歷的 List<String> 較大時，這可能會帶來一定的負面影響；相比之下 compute 和 computeIfAbsent 的好處在於，它們接受的引數為函式，只會在必要時才使用函式進行計算得出新 value 。在本文類似需求的情況下，就適用性和簡潔性而言， computeIfAbsent 要優於 compute 。在 JDK1.8 的 API 文件中，也說到在需要生成一個類似於 Map<K,Collection<V>> 的結構時， computeIfAbsent 很適合這種情況：

那 compute 方法適用於什麼情況呢？從前面的介紹可知， compute 方法更適用於更新 key 關聯的 value 時，新值依賴於舊值的情況 —— 比如統計一個 List<String> 中每個元素出現的次數：

public static Map<String,Integer> getElementCounts(List<String> list) {
  Map<String,Integer> countsMap = new HashMap<>();
  list.forEach(str -> countsMap.compute(str,v) -> v == null ? 1 : v + 1)); // 此時：新值 = 舊值 + 1
  return countsMap;
}
public static void main(String[] args) throws Exception {
  List<String> list = Arrays.asList("a","g");
  System.out.println("使用 compute 計算元素出現的次數：");
  Map<String,Integer> counts = getElementCounts(list);
  System.out.println(counts);
}

執行結果：

Java8 中還為 Map 添加了一些其他方便於編碼的新方法，請有興趣的讀者繼續發掘。

總結

以上所述是小編給大家介紹的Java8 中 Map 介面的新方法,希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回覆大家的。在此也非常感謝大家對我們網站的支援！
如果你覺得本文對你有幫助，歡迎轉載，煩請註明出處，謝謝！