Guava:好用的java類庫 學習小記

基礎功能

google guava中定義的String操做

在google guava中爲字符串操做提供了很大的便利,有老牌的判斷字符串是否爲空字符串或者爲null,用指定字符填充字符串,以及拆分合並字符串,字符串匹配的判斷等等。java

1. 使用com.google.common.base.Strings類的isNullOrEmpty(input)方法判斷字符串是否爲空程序員

1        //Strings.isNullOrEmpty(input) demo
2         String input = "";
3         boolean isNullOrEmpty = Strings.isNullOrEmpty(input);
4         System.out.println("input " + (isNullOrEmpty?"is":"is not") + " null or empty.");

2. 得到兩個字符串相同的前綴或者後綴正則表達式

 1        //Strings.commonPrefix(a,b) demo
 2         String a = "com.jd.coo.Hello";
 3         String b = "com.jd.coo.Hi";
 4         String ourCommonPrefix = Strings.commonPrefix(a,b);
 5         System.out.println("a,b common prefix is " + ourCommonPrefix);
 6 
 7         //Strings.commonSuffix(a,b) demo
 8         String c = "com.google.Hello";
 9         String d = "com.jd.Hello";
10         String ourSuffix = Strings.commonSuffix(c,d);
11         System.out.println("c,d common suffix is " + ourSuffix);

3. Strings的padStart和padEnd方法來補全字符串編程

1         int minLength = 4;
2         String padEndResult = Strings.padEnd("123", minLength, '0');
3         System.out.println("padEndResult is " + padEndResult);
4 
5         String padStartResult = Strings.padStart("1", 2, '0');
6         System.out.println("padStartResult is " + padStartResult);

4. 使用Splitter類來拆分字符串數組

Splitter類能夠方便的根據正則表達式來拆分字符串,能夠去掉拆分結果中的空串,能夠對拆分後的字串作trim操做,還能夠作二次拆分。安全

咱們先看一個基本的拆分例子:數據結構

        Iterable<String> splitResults = Splitter.onPattern("[,,]{1,}")
                .trimResults()
                .omitEmptyStrings()
                .split("hello,word,,世界,水平");

        for (String item : splitResults) {
            System.out.println(item);
        }

Splitter的onPattern方法傳入的是一個正則表達式,其後緊跟的trimResults()方法表示要對結果作trim,omitEmptyStrings()表示忽略空字符串,split方法會執行拆分操做。併發

split返回的結果爲Iterable<String>,咱們可使用for循環語句來逐個打印拆分字符串的結果。app

Splitter還有更強大的功能,作二次拆分,這裏二次拆分的意思是拆分兩次,例如咱們能夠將a=b;c=d這樣的字符串拆分紅一個Map<String,String>。ide

1         String toSplitString = "a=b;c=d,e=f";
2         Map<String,String> kvs = Splitter.onPattern("[,;]{1,}").withKeyValueSeparator('=').split(toSplitString);
3         for (Map.Entry<String,String> entry : kvs.entrySet()) {
4             System.out.println(String.format("%s=%s", entry.getKey(),entry.getValue()));
5         }

二次拆分首先是使用onPattern作第一次的拆分,而後再經過withKeyValueSeperator('')方法作第二次的拆分。

5. 有拆分字符串必然就有合併字符串,guava爲咱們提供了Joiner類來作字符串的合併

咱們先看一個簡單的示例:

1         String joinResult = Joiner.on(" ").join(new String[]{"hello","world"});
2         System.out.println(joinResult);

面例子中咱們使用Joiner.on(" ").join(xx)來合併字符串。很簡單也頗有效。

Splitter方法能夠對字符串作二次的拆分,對應的Joiner也能夠逆向操做,將Map<String,String>作合併。咱們看下下面的例子:

1         Map<String,String> map = new HashMap<String,String>();
2         map.put("a", "b");
3         map.put("c", "d");
4         String mapJoinResult = Joiner.on(",").withKeyValueSeparator("=").join(map);
5         System.out.println(mapJoinResult);

使用withKeyValueSeparator方法能夠對map作合併。合併的結果是:a=b,c=d

guava庫中還能夠對字符串作大小寫轉換(CaseFormat枚舉),能夠對字符串作模式匹配。使用起來都很方便。

 

guava中的對象操做封裝

在開發中常常會須要比較兩個對象是否相等,這時候咱們須要考慮比較的兩個對象是否爲null,而後再調用equals方法來比較是否相等,google guava庫的com.google.common.base.Objects類提供了一個靜態方法equals能夠避免咱們本身作是否爲空的判斷,示例以下:

1  Object a = null;
2  Object b = new Object();
3 boolean aEqualsB = Objects.equal(a, b);

Objects.equals的實現是很完美的,其實現代碼以下:

1 public static boolean equal(@Nullable Object a, @Nullable Object b) {
2     return a == b || (a != null && a.equals(b));
3   }

首先判斷a b是不是同一個對象,若是是同一對象,那麼直接返回相等,若是不是同一對象再判斷a不爲null而且a.equals(b). 這樣作既考慮了性能也考慮了null空指針的問題。

另外Objects類中還爲咱們提供了方便的重寫toString()方法的機制,咱們經過例子來了解一下吧:

 1 import com.google.common.base.Objects;
 2 
 3 public class ObjectsDemo {
 4     public static void main(String [] args) {
 5       Student jim = new Student();
 6         jim.setId(1);
 7         jim.setName("Jim");
 8         jim.setAge(13);
 9         System.out.println(jim.toString());
10     }
11 
12     public static class Student {
13         private int id;
14         private String name;
15         private int age;
16 
17         public int getId() {
18             return id;
19         }
20         public void setId(int id) {
21             this.id = id;
22         }
23 
24         public String getName() {
25             return name;
26         }
27         public void setName(String name) {
28             this.name = name;
29         }
30 
31         public int getAge() {
32             return age;
33         }
34         public void setAge(int age) {
35             this.age = age;
36         }
37 
38         public String toString() {
39             return Objects.toStringHelper(this.getClass())
40                     .add("id", id)
41                     .add("name", name)
42                     .add("age", age)
43                     .omitNullValues().toString();
44         }
45     }
46 }

咱們定義了一個Student類,該類有三個屬性,分別爲id,name,age,咱們重寫了toString()方法,在這個方法中咱們使用了Objects.toStringHelper方法,首先指定toString的類,而後依次add屬性名稱和屬性值,可使用omitNullValues()方法來指定忽略空值,最後調用其toString()方法,就能夠獲得一個格式很好的toString實現了。

上面代碼輸出的結果是:

Student{id=1, name=Jim, age=13}

這種方式寫起來很簡單,可讀性也很好,因此用Guava吧。

guava的Preconditions使用

guava的base包中提供的Preconditions類用來方便的作參數的校驗,他主要提供以下方法:

  1. checkArgument 接受一個boolean類型的參數和一個可選的errorMsg參數,這個方法用來判斷參數是否符合某種條件,符合什麼條件google guava不關心,在不符合條件時會拋出IllegalArgumentException異常
  2. checkState 和checkArgument參數和實現基本相同,從字面意思上咱們也能夠知道這個方法是用來判斷狀態是否正確的,若是狀態不正確會拋出IllegalStateException異常
  3. checkNotNull方法用來判斷參數是否不是null,若是爲null則會拋出NullPointerException空指針異常
  4. checkElementIndex方法用來判斷用戶傳入的數組下標或者list索引位置,是不是合法的,若是不合法會拋出IndexOutOfBoundsException
  5. checkPositionIndexes方法的做用和checkElementIndex方法類似,只是此方法的索引範圍是從0到size包括size,而上面的方法不包括size。

下面咱們看一個具體的使用示例:

 1 import com.google.common.base.Preconditions;
 2 
 3 public class PreconditionsDemo {
 4     public static void main(String[] args) {
 5         PreconditionsDemo demo = new PreconditionsDemo();
 6         demo.doSomething("Jim", 19, "hello world, hello java");
 7     }
 8 
 9     public void doSomething(String name, int age, String desc) {
10         Preconditions.checkNotNull(name, "name may not be null");
11         Preconditions.checkArgument(age >= 18 && age < 99, "age must in range (18,99)");
12         Preconditions.checkArgument(desc !=null && desc.length() < 10, "desc too long, max length is ", 10);
13 
14         //do things
15     }
16 }

上面例子中的doSomething()方法調用了三次Preconditions的方法,來對參數作校驗。

看似Preconditions實現很簡單,他的意義在於爲咱們提供了同一的參數校驗,並對不一樣的異常狀況拋出合適類型的異常,並對異常信息作格式化。

 

使用google guava的Optional接口來避免空指針錯誤

null會帶來不少問題,從開始有null開始有無數程序栽在null的手裏,null的含義是不清晰的,檢查null在大多數狀況下是不得不作的,而咱們又在不少時候忘記了對null作檢查,在咱們的產品真正投入使用的時候,空指針異常出現了,這是一種討厭的狀況。

鑑於此google的guava庫中提供了Optional接口來使null快速失敗,即在可能爲null的對象上作了一層封裝,在使用Optional靜態方法of時,若是傳入的參數爲null就拋出NullPointerException異常。

咱們看一個實際的例子:

1 import com.google.common.base.Optional;
2 
3 public class OptionalDemo {
4     public static void main(String[] args) {
5         Optional<Student> possibleNull = Optional.of(null);
6         possibleNull.get();
7     }
8     public static class Student { }
9 }

上面的程序,咱們使用Optional.of(null)方法,這時候程序會第一時間拋出空指針異常,這能夠幫助咱們儘早發現問題。

咱們再看另一個例子,咱們使用Optional.absent方法來初始化posibleNull實例,而後咱們get此對象,看看會是什麼狀況。

1 public class OptionalDemo {
2     public static void main(String[] args) {
3         Optional<Student> possibleNull = Optional.absent();
4         Student jim = possibleNull.get();
5     }
6     public static class Student { }
7 }

運行上面的程序,發現出現了:Exception in thread "main" java.lang.IllegalStateException: Optional.get() cannot be called on an absent value。

這樣使用也會有異常出來,那Optional到底有什麼意義呢?

使用Optional除了賦予null語義,增長了可讀性,最大的優勢在於它是一種傻瓜式的防禦。Optional迫使你積極思考引用缺失的狀況,由於你必須顯式地從Optional獲取引用。直接使用null很容易讓人忘掉某些情形,儘管FindBugs能夠幫助查找null相關的問題,可是咱們仍是認爲它並不能準確地定位問題根源。

如同輸入參數,方法的返回值也多是null。和其餘人同樣,你絕對極可能會忘記別人寫的方法method(a,b)會返回一個null,就好像當你實現method(a,b)時,也極可能忘記輸入參數a能夠爲null。將方法的返回類型指定爲Optional,也能夠迫使調用者思考返回的引用缺失的情形。

google guava Throwables幫你拋出異常,處理異常

guava類庫中的Throwables提供了一些異常處理的靜態方法,這些方法的從功能上分爲兩類,一類是幫你拋出異常,另一類是幫你處理異常。

也許你會想:爲何要幫咱們處理異常呢?咱們本身不會拋出異常嗎?

假定下面的方法是咱們要調用的方法。

1  public void doSomething() throws Throwable {
2         //ignore method body
3     }
4 
5     public void doSomethingElse() throws Exception {
6         //ignore method body
7     }

這兩個方法的簽名一個throws出了Throwable另一個throws出了Exception,他們沒有定義具體會拋出什麼異常,也就是說他們什麼異常都有可能拋出來,若是咱們要調用這樣的方法,就須要對他們的異常作一些處理了,咱們須要判斷什麼樣的異常須要拋出去,什麼樣的異常須要封裝成RuntimeException。而這些事情就是Throwables類要幫咱們作的事情。

假定咱們要實現一個doIt的方法,該方法要調用doSomething方法,而doIt的定義中只容許拋出SQLException,咱們能夠這樣作:

1     public void doIt() throws SQLException {
2         try {
3             doSomething();
4         } catch (Throwable throwable) {
5             Throwables.propagateIfInstanceOf(throwable, SQLException.class);
6             Throwables.propagateIfPossible(throwable);
7         }
8     }

請注意doIt的catch塊,下面這行代碼的意思是若是異常的類型是SQLException,那麼拋出這個異常

Throwables.propagateIfInstanceOf(throwable, SQLException.class);

第二行表示若是異常是Error類型,那麼拋出這個類型,不然將拋出RuntimeException,咱們知道RuntimeException是不須要在throws中聲明的。

Throwables.propagateIfPossible(throwable);

Throwables類還爲咱們提供了一些方便的異常處理幫助方法:

  1. 咱們能夠經過Throwables.getRooCause(Throwable)得到根異常
  2. 可使用getCausalChain方法得到異常的列表
  3. 能夠經過getStackTraceAsString得到異常堆棧的字符串

集合加強

guava的不可變集合

 

不可變集合的意義

不可變對象有不少優勢,包括:

  • 當對象被不可信的庫調用時,不可變形式是安全的;
  • 不可變對象被多個線程調用時,不存在競態條件問題
  • 不可變集合不須要考慮變化,所以能夠節省時間和空間。全部不可變的集合都比它們的可變形式有更好的內存利用率(分析和測試細節);
  • 不可變對象由於有固定不變,能夠做爲常量來安全使用。

建立對象的不可變拷貝是一項很好的防護性編程技巧。Guava爲全部JDK標準集合類型和Guava新集合類型都提供了簡單易用的不可變版本。
 JDK也提供了Collections.unmodifiableXXX方法把集合包裝爲不可變形式,但咱們認爲不夠好:

  • 笨重並且累贅:不能溫馨地用在全部想作防護性拷貝的場景;
  • 不安全:要保證沒人經過原集合的引用進行修改,返回的集合纔是事實上不可變的;
  • 低效:包裝過的集合仍然保有可變集合的開銷,好比並發修改的檢查、散列表的額外空間,等等。

若是你沒有修改某個集合的需求,或者但願某個集合保持不變時,把它防護性地拷貝到不可變集合是個很好的實踐。

重要提示:全部Guava不可變集合的實現都不接受null值。咱們對Google內部的代碼庫作過詳細研究,發現只有5%的狀況須要在集合中容許null元素,剩下的95%場景都是遇到null值就快速失敗。若是你須要在不可變集合中使用null,請使用JDK中的Collections.unmodifiableXXX方法。更多細節建議請參考「使用和避免null」

如何使用guava的不可變集合

1. 如何建立不可變集合

第一種方法使用builder建立:

 1 public class ImmutableDemo {
 2     public static void main(String[] args) {
 3         Set<String> immutableNamedColors = ImmutableSet.<String>builder()
 4                 .add("red", "green","black","white","grey")
 5                 .build();
 6         //immutableNamedColors.add("abc");
 7         for (String color : immutableNamedColors) {
 8             System.out.println(color);
 9         }
10     }
11 }

第二種方法使用of靜態方法建立:

        ImmutableSet.of("red","green","black","white","grey");

第三種方法使用copyOf靜態方法建立:

        ImmutableSet.copyOf(new String[]{"red","green","black","white","grey"});

2. 使用asList()得到不可變集合的list視圖

asList方法是在ImmutableCollection中定義,而全部的不可變集合都會從ImmutableCollection繼承,因此全部的不可變集合都會有asList()方法返回當前不可變集合的list視圖,這個視圖也是不可變的。

3. 不可變集合的使用

不可變集合的使用和普通集合同樣,只是不能使用他們的add,remove等修改集合的方法。

 

guava集合之Multiset

Multiset看似是一個Set,可是實質上它不是一個Set,它沒有繼承Set接口,它繼承的是Collection<E>接口,你能夠向Multiset中添加劇復的元素,Multiset會對添加的元素作一個計數。

它本質上是一個Set加一個元素計數器。

 1 import com.google.common.base.Splitter;
 2 import com.google.common.collect.HashMultiset;
 3 import com.google.common.collect.Multiset;
 4 
 5 public class MultisetDemo {
 6     public static void main(String[] args) {
 7         Multiset multiset = HashMultiset.create();
 8         String sentences = "this is a story, there is a good girl in the story.";
 9         Iterable<String> words = Splitter.onPattern("[^a-z]{1,}").omitEmptyStrings().trimResults().split(sentences);
10         for (String word : words) {
11             multiset.add(word);
12         }
13 
14         for (Object element : multiset.elementSet()) {
15             System.out.println((String)element + ":" + multiset.count(element));
16         }
17     }
18 }

在上面的示例中咱們對一段文字拆分紅一個一個的單詞,而後依次放入到multiset中,注意這段文字中有多個重複的單詞,而後咱們經過for循環遍歷multiset中的每個元素,並輸出他們的計數。輸出內容以下:

story:2 is:2 girl:1 there:1 a:2 good:1 the:1 in:1 this:1

顯然計數不是問題,Multiset還提供了add和remove的重載方法,能夠在add或這remove的同時指定計數的值。

經常使用實現 Multiset 接口的類有:

  • HashMultiset: 元素存放於 HashMap
  • LinkedHashMultiset: 元素存放於 LinkedHashMap,即元素的排列順序由第一次放入的順序決定
  • TreeMultiset:元素被排序存放於TreeMap
  • EnumMultiset: 元素必須是 enum 類型
  • ImmutableMultiset: 不可修改的 Mutiset

看到這裏你可能已經發現 Guava Collections 都是以 create 或是 of 這樣的靜態方法來構造對象。這是由於這些集合類大多有多個參數的私有構造方法,因爲參數數目不少,客戶代碼程序員使用起來就很不方便。並且以這種方式能夠返回原類型的子類型對象。另外,對於建立範型對象來說,這種方式更加簡潔。

 

google guava的BiMap:雙向Map

咱們知道Map是一種鍵值對映射,這個映射是鍵到值的映射,而BiMap首先也是一種Map,他的特別之處在於,既提供鍵到值的映射,也提供值到鍵的映射,因此它是雙向Map.

想象這麼一個場景,咱們須要作一個星期幾的中英文表示的相互映射,例如Monday對應的中文表示是星期一,一樣星期一對應的英文表示是Monday。這是一個絕好的使用BiMap的場景。

 1 mport com.google.common.collect.BiMap;
 2 import com.google.common.collect.HashBiMap;
 3 
 4 public class BiMapDemo {
 5     public static void main(String[] args) {
 6         BiMap<String,String> weekNameMap = HashBiMap.create();
 7         weekNameMap.put("星期一","Monday");
 8         weekNameMap.put("星期二","Tuesday");
 9         weekNameMap.put("星期三","Wednesday");
10         weekNameMap.put("星期四","Thursday");
11         weekNameMap.put("星期五","Friday");
12         weekNameMap.put("星期六","Saturday");
13         weekNameMap.put("星期日","Sunday");
14 
15         System.out.println("星期日的英文名是" + weekNameMap.get("星期日"));
16         System.out.println("Sunday的中文是" + weekNameMap.inverse().get("Sunday"));
17     }
18 }

BiMap的值鍵對的Map能夠經過inverse()方法獲得。

BiMap的經常使用實現有:

  1. HashBiMap: key 集合與 value 集合都有 HashMap 實現
  2. EnumBiMap: key 與 value 都必須是 enum 類型
  3. ImmutableBiMap: 不可修改的 BiMap

google guava的Multimaps:一鍵多值的Map

有時候咱們須要這樣的數據類型Map<String,Collection<String>>,guava中的Multimap就是爲了解決這類問題的。

Multimap的實現

Multimap提供了豐富的實現,因此你能夠用它來替代程序裏的Map<K, Collection<V>>,具體的實現以下:

實現 Key實現 Value實現
ArrayListMultimap HashMap ArrayList
HashMultimap HashMap HashSet
LinkedListMultimap LinkedHashMap LinkedList
LinkedHashMultimap LinkedHashMap LinkedHashSet
TreeMultimap TreeMap TreeSet
ImmutableListMultimap ImmutableMap ImmutableList
ImmutableSetMultimap ImmutableMap ImmutableSet

咱們經過一個示例來了解Multimap的使用方法:

 1 public class MutliMapTest {  
 2     public static void main(String... args) {  
 3   Multimap<String, String> myMultimap = ArrayListMultimap.create();  
 4     
 5   // 添加鍵值對
 6   myMultimap.put("Fruits", "Bannana"); 
 7  //給Fruits元素添加另外一個元素 
 8   myMultimap.put("Fruits", "Apple");  
 9   myMultimap.put("Fruits", "Pear");  
10   myMultimap.put("Vegetables", "Carrot");  
11     
12   // 得到multimap的size
13   int size = myMultimap.size();  
14   System.out.println(size);  // 4  
15     
16   // 得到Fruits對應的全部的值
17   Collection<string> fruits = myMultimap.get("Fruits");  
18   System.out.println(fruits); // [Bannana, Apple, Pear]  
19     
20   Collection<string> vegetables = myMultimap.get("Vegetables");  
21   System.out.println(vegetables); // [Carrot]  
22     
23   //遍歷Mutlimap  
24   for(String value : myMultimap.values()) {  
25    System.out.println(value);  
26   }  
27     
28   // Removing a single value  
29   myMultimap.remove("Fruits","Pear");  
30   System.out.println(myMultimap.get("Fruits")); // [Bannana, Pear]  
31     
32   // Remove all values for a key  
33   myMultimap.removeAll("Fruits");  
34   System.out.println(myMultimap.get("Fruits")); // [] (Empty Collection!)  
35 }  
36 }  

google guava集合之Table

在guava庫中還提供了一種二維表結構:Table。使用Table能夠實現二維矩陣的數據結構,能夠是稀溜矩陣。

咱們看一個使用示例:

 1 public class TableDemo {
 2     public static void main(String[] args) {
 3         Table<Integer, Integer, String> table = HashBasedTable.create();
 4         for (int row = 0; row < 10; row++) {
 5             for (int column = 0; column < 5; column++) {
 6                 table.put(row, column, "value of cell (" + row + "," + column + ")");
 7             }
 8         }
 9         for (int row=0;row<table.rowMap().size();row++) {
10             Map<Integer,String> rowData = table.row(row);
11             for (int column =0;column < rowData.size(); column ++) {
12                 System.out.println("cell(" + row + "," + column + ") value is:" + rowData.get(column));
13             }
14         }
15     }
16 }

在上面示例中咱們經過HashBasedTable建立了一個行類型爲Integer,列類型也爲Integer,值爲String的Table。而後咱們使用put方法向Table中添加了一些值,而後顯示這些值

Guava集合:使用Iterators簡化Iterator操做

Iterators是Guava中對Iterator迭代器操做的幫助類,這個類提供了不少有用的方法來簡化Iterator的操做。

1. 判斷迭代器中的元素是否都知足某個條件 all 方法

 1         List<String> list = Lists.newArrayList("Apple","Pear","Peach","Banana");
 2 
 3         Predicate<String> condition = new Predicate<String>() {
 4             @Override
 5             public boolean apply(String input) {
 6                 return ((String)input).startsWith("P");
 7             }
 8         };
 9         boolean allIsStartsWithP = Iterators.all(list.iterator(), condition);
10         System.out.println("all result == " + allIsStartsWithP);

all方法的第一個參數是Iterator,第二個參數是Predicate<String>的實現,這個方法的意義是不須要咱們本身去寫while循環了,他的內部實現中幫咱們作了循環,把循環體中的條件判斷抽象出來了。

2. 經過any判斷迭代器中是否有一個知足條件的記錄,any方法的參數和all方法同樣,就再也不具體舉例了

3. get方法得到迭代器中的第x個元素

 String secondElement = Iterators.get(list.iterator(), 1);

4. filter方法過濾符合條件的項

 

1        Iterator<String> startPElements = Iterators.filter(list.iterator(), new Predicate<String>() {
2             @Override
3             public boolean apply(String input) {
4                 return input.startsWith("P");
5             }
6         });

filter方法的第一個參數是源迭代器,第二個參數是Predicate的實現,其apply方法會返回當前元素是否符合條件。

 

5. find方法返回符合條件的第一個元素

1         String length5Element = Iterators.find(list.iterator(), new Predicate<String>() {
2             @Override
3             public boolean apply(String input) {
4                 return input.length() == 5;
5             }
6         });

6. transform方法,對迭代器元素作轉換

1         Iterator<Integer> countIterator = Iterators.transform(list.iterator(), new Function<String, Integer>() {
2             @Override
3             public Integer apply(String input) {
4                 return input.length();
5             }
6         });

上面的例子中咱們將字符串轉換成了其長度,transform方法輸出的是另一個Iterator.

相關文章
相關標籤/搜索