Guava - 拯救垃圾程式碼，寫出優雅高效，效率提升N倍

最近在看一個同學程式碼的時候，發現程式碼中大量使用了 Google 開源的 Guava 核心庫中的內容，讓程式碼簡單清晰了不少，故學習分享出 Guava 中我認為最實用的功能。

Guava 專案是 Google 公司開源的 Java 核心庫，它主要是包含一些在 Java 開發中經常使用到的功能，如資料校驗、不可變集合、計數集合，集合增強操作、I/O、快取、字串操作等。並且 Guava 廣泛用於 Google 內部的 Java 專案中，也被其他公司廣泛使用，甚至在新版 JDK 中直接引入了 Guava 中的優秀類庫，所以質量毋庸置疑。

使用方式直接 mavan 依賴引入。

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.0-jre</version>
</dependency>

資料校驗

資料校驗說來十分簡單，一是非空判斷，二是預期值判斷。非空判斷我想每一個 Java 開發者都很熟悉，一開始都經常和 NullPointException 打交道。處理的方式我們自然是一個 if( xx == null) 就能輕鬆解決。預期值判斷也是類似，檢查資料值是不是自己想要的結果即可。

即使這麼簡單的操作，我們是不是還經常出錯呢？而且寫起來的程式碼總是一行判斷一行異常丟擲，怎麼看都覺得那麼優雅。還好，現在就來嘗試第一次使用 Guava 吧。

非空判斷

String param = "未讀程式碼";
String name = Preconditions.checkNotNull(param);
System.out.println(name); // 未讀程式碼
String param2 = null;
String name2 = Preconditions.checkNotNull(param2); // NullPointerException
System.out.println(name2);

引入了 Guava 後可以直接使用 Preconditions.checkNotNull 進行非空判斷，好處為覺得有兩個，一是語義清晰程式碼優雅；二是你也可以自定義報錯資訊，這樣如果引數為空，報錯的資訊清晰，可以直接定位到具體引數。

String param2 = null;
String name2 = Preconditions.checkNotNull(param2,"param2 is null");
// java.lang.NullPointerException: param2 is null

預期值判斷

和非空判斷類似，可以比較當前值和預期值，如果不相等可以自定義報錯資訊丟擲。

String param = "www.wdbyte.com2";
String wdbyte = "www.wdbyte.com";
Preconditions.checkArgument(wdbyte.equals(param), "[%s] 404 NOT FOUND", param);
// java.lang.IllegalArgumentException: [www.wdbyte.com2] 404 NOT FOUND

是否越界

Preconditions 類還可以用來檢查陣列和集合的元素獲取是否越界。

// Guava 中快速建立ArrayList
List<String> list = Lists.newArrayList("a", "b", "c", "d");
// 開始校驗
int index = Preconditions.checkElementIndex(5, list.size());
// java.lang.IndexOutOfBoundsException: index (5) must be less than size (4)

程式碼中快速建立 List 的方式也是 Guava 提供的，後面會詳細介紹 Guava 中集合建立的超多姿勢。

不可變的集合

建立不可變集合是我個人最喜歡 Guava 的一個原因，因為建立一個不能刪除、不能修改、不能增加元素的集合實在是太實用了。這樣的集合你完全不用擔心發生什麼問題，總的來說有下面幾個優點：

1. 執行緒安全，因為不能修改任何元素，可以隨意多執行緒使用且沒有併發問題。
2. 可以無憂的提供給第三方使用，反正修改不了。
3. 減少記憶體佔用，因為不能改變，所以內部實現可以最大程度節約記憶體佔用。
4. 可以用作常量集合。

建立方式

說了那麼多，那麼到底怎麼使用呢？趕緊擼起程式碼來。

// 建立方式1：of
ImmutableSet<String> immutableSet = ImmutableSet.of("a", "b", "c");
immutableSet.forEach(System.out::println);
// a
// b
// c

// 建立方式2：builder
ImmutableSet<String> immutableSet2 = ImmutableSet.<String>builder()
    .add("hello")
    .add(new String("未讀程式碼"))
    .build();
immutableSet2.forEach(System.out::println);
// hello
// 未讀程式碼

// 建立方式3：從其他集合中拷貝建立
ArrayList<String> arrayList = new ArrayList();
arrayList.add("www.wdbyte.com");
arrayList.add("https");
ImmutableSet<String> immutableSet3 = ImmutableSet.copyOf(arrayList);
immutableSet3.forEach(System.out::println);
// www.wdbyte.com
// https

都可以正常列印遍歷結果，但是如果進行增刪改，會直接報 UnsupportedOperationException .

其實 JDK 中也提供了一個不可變集合，可以像下面這樣建立。

ArrayList<String> arrayList = new ArrayList();
arrayList.add("www.wdbyte.com");
arrayList.add("https");
// JDK Collections 建立不可變 List
List<String> list = Collections.unmodifiableList(arrayList);
list.forEach(System.out::println);// www.wdbyte.com https
list.add("未讀程式碼"); // java.lang.UnsupportedOperationException

注意事項

1. 使用 Guava 建立的不可變集合是拒絕 null 值的，因為在 Google 內部調查中，95% 的情況下都不需要放入 null 值。

2. 使用 JDK 提供的不可變集合建立成功後，原集合新增元素會體現在不可變集合中，而 Guava 的不可變集合不會有這個問題。

   List<String> arrayList = new ArrayList<>();
   arrayList.add("a");
   arrayList.add("b");
   List<String> jdkList = Collections.unmodifiableList(arrayList);
   ImmutableList<String> immutableList = ImmutableList.copyOf(arrayList);
   arrayList.add("ccc");
   jdkList.forEach(System.out::println);// result: a b ccc
   System.out.println("-------");
   immutableList.forEach(System.out::println);// result: a b
   

3. 如果不可變集合的元素是引用物件，那麼引用物件的屬性是可以更改的。

其他不可變集合

不可變集合除了上面演示的 set 之外，還有很多不可變集合，下面是 Guava 中不可變集合和其他集合的對應關係。

可變集合介面	屬於JDK還是Guava	不可變版本
Collection	JDK	ImmutableCollection
List	JDK	ImmutableList
Set	JDK	ImmutableSet
SortedSet/NavigableSet	JDK	ImmutableSortedSet
Map	JDK	ImmutableMap
SortedMap	JDK	ImmutableSortedMap
Multiset	Guava	ImmutableMultiset
SortedMultiset	Guava	ImmutableSortedMultiset
Multimap	Guava	ImmutableMultimap
ListMultimap	Guava	ImmutableListMultimap
SetMultimap	Guava	ImmutableSetMultimap
BiMap	Guava	ImmutableBiMap
ClassToInstanceMap	Guava	ImmutableClassToInstanceMap
Table	Guava	ImmutableTable

集合操作工廠

其實這裡只會介紹一個建立方法，但是為什麼還是單獨拿出來介紹了呢？看下去你就會大呼好用。雖然 JDK 中已經提供了大量的集合相關的操作方法，用起來也是非常的方便，但是 Guava 還是增加了一些十分好用的方法，保證讓你用上一次就愛不釋手，

建立集合。

// 建立一個 ArrayList 集合
List<String> list1 = Lists.newArrayList();
// 建立一個 ArrayList 集合，同時塞入3個資料
List<String> list2 = Lists.newArrayList("a", "b", "c");
// 建立一個 ArrayList 集合，容量初始化為10
List<String> list3 = Lists.newArrayListWithCapacity(10);

LinkedList<String> linkedList1 = Lists.newLinkedList();
CopyOnWriteArrayList<String> cowArrayList = Lists.newCopyOnWriteArrayList();

HashMap<Object, Object> hashMap = Maps.newHashMap();
ConcurrentMap<Object, Object> concurrentMap = Maps.newConcurrentMap();
TreeMap<Comparable, Object> treeMap = Maps.newTreeMap();

HashSet<Object> hashSet = Sets.newHashSet();
HashSet<String> newHashSet = Sets.newHashSet("a", "a", "b", "c");

Guava 為每一個集合都新增了工廠方法建立方式，上面已經展示了部分集合的工廠方法建立方式。是不是十分的好用呢。而且可以在建立時直接扔進去幾個元素，這個簡直太讚了，再也不用一個個 add 了。

集合交集並集差集

過於簡單，直接看程式碼和輸出結果吧。

Set<String> newHashSet1 = Sets.newHashSet("a", "a", "b", "c");
Set<String> newHashSet2 = Sets.newHashSet("b", "b", "c", "d");

// 交集
SetView<String> intersectionSet = Sets.intersection(newHashSet1, newHashSet2);
System.out.println(intersectionSet); // [b, c]

// 並集
SetView<String> unionSet = Sets.union(newHashSet1, newHashSet2);
System.out.println(unionSet); // [a, b, c, d]

// newHashSet1 中存在，newHashSet2 中不存在
SetView<String> setView = Sets.difference(newHashSet1, newHashSet2);
System.out.println(setView); // [a]

有數量的集合

這個真的太有用了，因為我們經常會需要設計可以計數的集合，或者 value 是 List 的 Map 集合，如果說你不太明白，看下面這段程式碼，是否某天夜裡你也這樣寫過。

1. 統計相同元素出現的次數（下面的程式碼我已經儘可能精簡寫法了）。

   JDK 原生寫法：

   // Java 統計相同元素出現的次數。
   List<String> words = Lists.newArrayList("a", "b", "c", "d", "a", "c");
   Map<String, Integer> countMap = new HashMap<String, Integer>();
   for (String word : words) {
       Integer count = countMap.get(word);
       count = (count == null) ? 1 : ++count;
       countMap.put(word, count);
   }
   countMap.forEach((k, v) -> System.out.println(k + ":" + v));
   /**
    * result:
    * a:2
    * b:1
    * c:2
    * d:1
    */
   

   儘管已經儘量優化程式碼，程式碼量還是不少的，那麼在 Guava 中有什麼不一樣呢？在 Guava. 中主要是使用 HashMultiset 類，看下面。

   ArrayList<String> arrayList = Lists.newArrayList("a", "b", "c", "d", "a", "c");
   HashMultiset<String> multiset = HashMultiset.create(arrayList);
   multiset.elementSet().forEach(s -> System.out.println(s + ":" + multiset.count(s)));
   /**
    * result:
    * a:2
    * b:1
    * c:2
    * d:1
    */
   

   是的，只要把元素新增進去就行了，不用在乎是否重複，最後都可以使用 count 方法統計重複元素數量。看著舒服，寫著優雅，HashMultiset 是 Guava 中實現的 Collection 類，可以輕鬆統計元素數量。

2. 一對多，value 是 List 的 Map 集合。

   假設一個場景，需要把很多動物按照種類進行分類，我相信最後你會寫出類似的程式碼。

   JDK 原生寫法：

   HashMap<String, Set<String>> animalMap = new HashMap<>();
   HashSet<String> dogSet = new HashSet<>();
   dogSet.add("旺財");
   dogSet.add("大黃");
   animalMap.put("狗", dogSet);
   HashSet<String> catSet = new HashSet<>();
   catSet.add("加菲");
   catSet.add("湯姆");
   animalMap.put("貓", catSet);
   System.out.println(animalMap.get("貓")); // [加菲, 湯姆]
   

   最後一行查詢貓得到了貓類的 "加菲" 和 ”湯姆“。這個程式碼簡直太煩做了，如果使用 Guava 呢？

   // use guava
   HashMultimap<String, String> multimap = HashMultimap.create();
   multimap.put("狗", "大黃");
   multimap.put("狗", "旺財");
   multimap.put("貓", "加菲");
   multimap.put("貓", "湯姆");
   System.out.println(multimap.get("貓")); // [加菲, 湯姆]
   

   HashMultimap 可以扔進去重複的 key 值，最後獲取時可以得到所有的 value 值，可以看到輸出結果和 JDK 寫法上是一樣的，但是程式碼已經無比清爽。

字串操作

作為開發中最長使用的資料型別，字串操作的增強可以讓開發更加高效。

字元拼接

JDK 8 中其實已經內建了字串拼接方法，但是它只是簡單的拼接，沒有額外操作，比如過濾掉 null 元素，去除前後空格等。先看一下 JDK 8 中字串拼接的幾種方式。

// JDK 方式一
ArrayList<String> list = Lists.newArrayList("a", "b", "c", null);
String join = String.join(",", list);
System.out.println(join); // a,b,c,null
// JDK 方式二
String result = list.stream().collect(Collectors.joining(","));
System.out.println(result); // a,b,c,null
// JDK 方式三
StringJoiner stringJoiner = new StringJoiner(",");
list.forEach(stringJoiner::add);
System.out.println(stringJoiner.toString()); // a,b,c,null

可以看到 null 值也被拼接到了字串裡，這有時候不是我們想要的，那麼使用 Guava 有什麼不一樣呢？

ArrayList<String> list = Lists.newArrayList("a", "b", "c", null);
String join = Joiner.on(",").skipNulls().join(list);
System.out.println(join); // a,b,c

String join1 = Joiner.on(",").useForNull("空值").join("旺財", "湯姆", "傑瑞", null);
System.out.println(join1); // 旺財,湯姆,傑瑞,空值

可以看到使用 skipNulls() 可以跳過空值，使用 useFornull(String) 可以為空值自定義顯示文字。

字串分割

JDK 中是自帶字串分割的，我想你也一定用過，那就是 String 的 split 方法，但是這個方法有一個問題，就是如果最後一個元素為空，那麼就會丟棄，奇怪的是第一個元素為空卻不會丟棄，這就十分迷惑，下面通過一個例子演示這個問題。

String str = ",a,,b,";
String[] splitArr = str.split(",");
Arrays.stream(splitArr).forEach(System.out::println);
System.out.println("------");
/**
 *
 * a
 * 
 * b
 * ------
 */

你也可以自己測試下，最後一個元素不是空，直接消失了。

如果使用 Guava 是怎樣的操作方式呢？Guava 提供了 Splitter 類，並且有一系列的操作方式可以直觀的控制分割邏輯。

String str = ",a ,,b ,";
Iterable<String> split = Splitter.on(",")
    .omitEmptyStrings() // 忽略空值
    .trimResults() // 過濾結果中的空白
    .split(str);
split.forEach(System.out::println);
/**
 * a
 * b
 */

快取

在開發中我們可能需要使用小規模的快取，來提高訪問速度。這時引入專業的快取中介軟體可能又覺得浪費。現在可以了， Guava 中提供了簡單的快取類，且可以根據預計容量、過期時間等自動過期已經新增的元素。即使這樣我們也要預估好可能佔用的記憶體空間，以防記憶體佔用過多。

現在看一下在 Guava 中快取該怎麼用。

@Test
public void testCache() throws ExecutionException, InterruptedException {

    CacheLoader cacheLoader = new CacheLoader<String, Animal>() {
        // 如果找不到元素，會呼叫這裡
        @Override
        public Animal load(String s) {
            return null;
        }
    };
    LoadingCache<String, Animal> loadingCache = CacheBuilder.newBuilder()
        .maximumSize(1000) // 容量
        .expireAfterWrite(3, TimeUnit.SECONDS) // 過期時間
        .removalListener(new MyRemovalListener()) // 失效監聽器
        .build(cacheLoader); //
    loadingCache.put("狗", new Animal("旺財", 1));
    loadingCache.put("貓", new Animal("湯姆", 3));
    loadingCache.put("狼", new Animal("灰太狼", 4));

    loadingCache.invalidate("貓"); // 手動失效

    Animal animal = loadingCache.get("狼");
    System.out.println(animal);
    Thread.sleep(4 * 1000);
    // 狼已經自動過去，獲取為 null 值報錯
    System.out.println(loadingCache.get("狼"));
    /**
     * key=貓,value=Animal{name='湯姆', age=3},reason=EXPLICIT
     * Animal{name='灰太狼', age=4}
     * key=狗,value=Animal{name='旺財', age=1},reason=EXPIRED
     * key=狼,value=Animal{name='灰太狼', age=4},reason=EXPIRED
     *
     * com.google.common.cache.CacheLoader$InvalidCacheLoadException: CacheLoader returned null for key 狼.
     */
}

/**
 * 快取移除監聽器
 */
class MyRemovalListener implements RemovalListener<String, Animal> {

    @Override
    public void onRemoval(RemovalNotification<String, Animal> notification) {
        String reason = String.format("key=%s,value=%s,reason=%s", notification.getKey(), notification.getValue(), notification.getCause());
        System.out.println(reason);
    }
}

class Animal {
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "Animal{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
    }

    public Animal(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

這個例子中主要分為 CacheLoader、MyRemovalListener、LoadingCache。

CacheLoader 中重寫了 load 方法，這個方法會在查詢快取沒有命中時被呼叫，我這裡直接返回了 null，其實這樣會在沒有命中時丟擲 CacheLoader returned null for key 異常資訊。

MyRemovalListener 作為快取元素失效時的監聽類，在有元素快取失效時會自動呼叫 onRemoval 方法，這裡需要注意的是這個方法是同步方法，如果這裡耗時較長，會阻塞直到處理完成。

LoadingCache 就是快取的主要操作物件了，常用的就是其中的 put 和 get 方法了。

總結

上面介紹了我認為最常用的 Guava 功能，Guava 作為 Google 公司開源的 Java 開發核心庫，個人覺得實用性還是很高的。引入後不僅能快速的實現一些開發中常用的功能，而且還可以讓程式碼更加的優雅簡潔。我覺得適用於每一個 Java 專案。Guava 的其他的功能你也可以自己去發現。它的 Github 地址是：https://github.com/google/guava.

參考

1. https://github.com/google/guava/wiki

訂閱

文章已經收錄在 Github.com/niumoo/JavaNotes ，歡迎Star和指教。更有一線大廠面試點，Java程式設計師需要掌握的核心知識等文章，也整理了很多我的文字，歡迎 Star 和完善，希望我們一起變得優秀。

文章每週持續更新，有幫助可以點個「贊」或「分享」，都是支援，我都喜歡！

要實時關注更新的文章以及分享的乾貨，可以關注 未讀程式碼 公眾號（下方二維碼）或者我的網站。