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

未讀程式碼發表於2020-10-28

Google Guava

最近在看一個同學程式碼的時候，發現程式碼中大量使用了 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：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

注意事項

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

使用 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

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

其他不可變集合

不可變集合除了上面演示的 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 集合，如果說你不太明白，看下面這段程式碼，是否某天夜裡你也這樣寫過。

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

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 類，可以輕鬆統計元素數量。

一對多，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.

參考

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

VSCode使用技巧，程式碼編寫效率提升2倍以上！
2023-03-08
VSCode
如何寫出優雅的程式碼？
2019-04-10
寫出優雅的js程式碼
2018-11-28
JS
如何寫出優雅耐看的JavaScript程式碼
2019-09-20
JavaScript
【優雅寫程式碼系統】springboot+mybatis+pagehelper+mybatisplus+druid教你如何優雅寫程式碼
2020-06-11
Spring BootMyBatisUI
助您寫出優雅的Java程式碼七點建議
2019-01-15
Java
如何用 es6+ 寫出優雅的 js 程式碼
2018-12-07
JS
編寫更優雅的 JavaScript 程式碼
2018-09-05
JavaScript
如何用 SpringBoot 優雅的寫程式碼
2018-04-05
Spring Boot
這樣使用 IDEA ，效率提升10倍！| IDEA 高效使用指南
2021-12-19
Idea
如何提高Java程式碼質量-優雅的寫程式碼
2018-08-28
Java
編寫優雅程式碼的最佳實踐
2018-04-24
Java動態編譯優化——提升編譯速度（N倍）
2018-12-06
Java編譯優化
golang如何優雅的編寫事務程式碼
2020-05-25
Golang
PHPer這樣寫程式碼也許更優雅
2018-06-21
PHP
如何寫出高效能程式碼之優化資料訪問
2022-06-06
優化
優雅的程式碼
2021-07-01
想寫出優雅的程式碼？試試這些ES6小tips
2018-07-15
30個python教你學會優雅的寫程式碼
2022-07-13
Python
我是如何將業務程式碼寫優雅的
2019-04-30
如何寫出高效能程式碼之優化記憶體回收(GC)
2022-05-03
優化記憶體GC
48 條高效率的 PHP 優化寫法
2018-06-01
PHP優化
看promise教你如何優雅的寫js非同步程式碼
2018-05-20
PromiseJS非同步
【提升學習力】如何讓學習效果提升 N 倍
2018-11-23
【硬核】23種設計模式娓娓道來，助你優雅的編寫出漂亮程式碼！
2021-04-08
設計模式
9條消除if...else的錦囊妙計，助你寫出更優雅的程式碼
2021-01-31
幾個簡單的技巧讓你寫出的vue.js程式碼更優雅
2018-12-04
Vue.js
如何寫出更優質的程式碼
2023-02-11
幾行程式碼提升Pandas效能150倍
2024-06-27
行程
怎樣寫出優雅的HTML結構？
2024-12-09
HTML
使用 Guava Retry 優雅的實現重試機制
2023-12-05
Guava
用 100 行程式碼提升 10 倍的效能
2018-11-18
行程
用好 ChatGPT，讓你工作效率提升10倍
2023-03-08
ChatGPT
如何寫出優雅的程式碼？試試這些開源專案「GitHub 熱點速覽」
2023-10-30
Github
小程式redux效能優化，提升三倍渲染速度
2018-08-06
Redux優化
如何優雅的打包前端程式碼
2019-10-30
前端
執行效率高的程式碼-可以這樣寫出來～
2021-08-18
如何寫出高效能程式碼(二)巧用資料特性
2022-04-06