Guava 2:Basic utilities基本工具

1、引子

Guava的經典很大一部分緣由來源於對於基礎工具類的封裝，使用這些類可以讓咱們的代碼更加優雅且完善，這些類大部分都在com.google.common.base包下。

注：JDK有不少借鑑guava的地方，本文只講解guava,若是jdk中有相似的實現，沒必要疑慮。

2、基本工具

按照官網介紹，Guava base包下有一些經典工具，以下：

2.1 Optional<T>

1.做用

在構造對象的時候就明確申明該對象是否可能爲null,快速失敗拒絕null值,能夠避免空指針異常。

2.簡單使用

 1 /**
 2  * @Description Optional:一個指向值對象引用的對象實例，使得構造對象時就明確申明是否支持null
 3  * @author denny
 4  * @date 2018/7/24 下午2:23
 5  */
 6 public class OptionalTest {
 7     public static void main(String[] args) {
 8         Integer a = null;
 9         Integer b = 1;
10         // 支持null、非null
11         Optional<Integer> optionalA1 = Optional.fromNullable(a);
12         Optional<Integer> optionalA2 = Optional.fromNullable(b);
13         // 不支持null,參數爲null報錯
14         Optional<Integer> optionalB = Optional.of(b);
15         // 不包含引用對象的實例()
16         Optional<Integer> optionalC = Optional.absent();
17 
18         // 不存在實例，不進入
19         if(optionalA1.isPresent()){
20             System.out.println(" A1 get="+optionalA1.get());
21         }
22         // 存在實例，進入
23         if(optionalA2.isPresent()){
24             System.out.println(" A2 get="+optionalA2.get());
25         }
26         // 存在實例，進入
27         if(optionalB.isPresent()){
28             System.out.println(" B get="+optionalB.get());
29         }
30         // 不存在實例，不進入
31         if(optionalC.isPresent()){
32             System.out.println(" C get="+optionalC.get());
33         }
34 
35     }
36 }

結果以下：

 A2 get=1
 B get=1

2.2 Preconditions

 1.做用

前置條件校驗，讓方法中的條件檢查更簡單。

2.簡單使用

 1 /**
 2  * @Description 前置條件校驗
 3  * @author denny
 4  * @date 2018/7/24 下午3:14
 5  */
 6 public class PreconditionsTest {
 7     public static void main(String[] args) {
 8 
 9         /** 1.空指針校驗 */
10         Integer a = null;
11         // 直接拋出空指針異常
12         Preconditions.checkNotNull(a);
13         // 拋出指定錯誤消息的空指針異常
14         Preconditions.checkNotNull(a,"a is null!");
15         // 拋出指定錯誤消息(指定參數替換掉%s)的空指針異常
16         Preconditions.checkNotNull(a,"a is null ,a=%s",a);
17 
18         /** 2.方法入參校驗 */
19         // 方法入參校驗：校驗第一參是否true
20         Preconditions.checkArgument(a!=null && a>=0,"參數a不知足條件! a=%s",a);
21 
22         /** 3.檢查對象的狀態 */
23         // 模擬：訂單號做爲方法入參，修改訂單狀態爲已完成。
24         Order order = Order.builder().id(1).build();
25         // 狀態校驗，非入參校驗
26         Preconditions.checkState(order.getState()>0,"訂單狀態非法! status=%s",order.getState());
27 
28         /** 4.下標越界校驗 */
29         List list = Lists.newArrayList(1,2,3);
30         //Preconditions.checkElementIndex(5,list.size(),"下標非法！");
31         
32         /** 5.下標越界、start<end 校驗 */
33         Preconditions.checkPositionIndexes(0,5,list.size());
34     }
35 }

2.3 Objects（JDK7以上直接使用java.util.Objects）

 1.做用

常見Object方法，簡化Object方法實現，如hashCode()和toString()。

2.簡單使用

4個典型方法：

equal、hashcode、toString、compare/compareTo

 1 /**
 2  * @Description 簡化對象的一些方法
 3  * @author denny
 4  * @date 2018/7/24 下午4:08
 5  */
 6 public class ObjectsTest {
 7     public static void main(String[] args) {
 8         /** 1.equals */
 9         //false
10         System.out.println(Objects.equal("a",null));
11         System.out.println(Objects.equal("a","b"));
12         // true
13         System.out.println(Objects.equal("a","a"));
14         System.out.println(Objects.equal(null,null));
15 
16         /** 2.hashCode */
17         Order order1 = Order.builder().id(1).state(2).build();
18         Order order2 = Order.builder().id(2).state(1).build();
19         System.out.println(Objects.hashCode(order1,order2));
20 
21         /** 2.toString */
22         String str = MoreObjects.toStringHelper(order1).add("x",1).toString();
23         System.out.println(str);
24 
25         /** 2.compare/compareTo */
26         // 這裏比較訂單大小，比較順序：id,狀態,即先比較ID再比較狀態，有一個不相等就當即返回結果
27         int result = ComparisonChain.start()
28             .compare(order1.getId(),order2.getId())
29             .compare(order1.getState(),order2.getState())
30             .result();
31         System.out.println(result);
32     }
33 }

打印結果：

1 false
2 false
3 true
4 true
5 114363
6 Order{x=1}
7 -1

2.4 Ordering<T>（JDK8建議直接使用Stream,Comparator）

 1.做用

排序,」流式風格比較器」。支持多重排序，並使用到集合中。這個類不在base包下，在collect包下.可能考慮到集合中元素排序吧...

2.簡單使用

reverse() :獲取語義相反的排序器
nullsFirst():null值排到最前面。
nullsLast():null值排到最後面。
compound(Comparator):合成另外一個比較器，以處理當前排序器中的相等狀況。
lexicographical():基於處理類型T的排序器，返回該類型的可迭代對象Iterable<T>的排序器。
onResultOf(Function):對集合中元素調用Function，再按返回值用當前排序器排序。

 1 package guava.base;
 2 
 3 import com.google.common.base.Function;
 4 import com.google.common.collect.Lists;
 5 import com.google.common.collect.Ordering;
 6 import guava.base.domain.Order;
 7 
 8 import java.util.List;
 9 
10 /**
11  * @Description 排序
12  * @author denny
13  * @date 2018/7/24 下午6:01
14  */
15 public class OrderingTest {
16     public static void main(String[] args) {
17         /**天然排序: 數字升序，時間升序*/
18         // 簡單數據排序
19         Ordering<Integer> integerOrdering = Ordering.natural().nullsFirst();
20         List<Integer> list = Lists.newArrayList(1,3,null,5,4,2);
21         // 天然排序，空前置
22         System.out.println("1.天然排序："+integerOrdering.sortedCopy(list));
23         System.out.println("2.天然反轉排序："+integerOrdering.reverse().sortedCopy(list));
24 
25         // 根據apply返回值排序
26         Ordering<Order> orderOrdering = Ordering.natural().onResultOf(new Function<Order, Integer>() {
27             public Integer apply(Order order){
28                 /* 訂單ID天然排序 */
29                 return order.getId();
30             }
31         });
32         List<Order> orders = Lists.newArrayList(new Order(1,0),new Order(3,1),new Order(2,2));
33         System.out.println("3.根據訂單ID天然排序："+orderOrdering.sortedCopy(orders));
34         System.out.println("4.根據訂單ID天然排序,求最大值："+orderOrdering.max(orders));
35         System.out.println("5.根據訂單ID天然排序,求最小值："+orderOrdering.min(orders));
36         System.out.println("6.求ID最小的k個元素："+orderOrdering.leastOf(orders,2));
37         System.out.println("7.求ID最大的k個元素："+orderOrdering.greatestOf(orders,2));
38     }
39 }

結果以下：

1.天然排序：[null, 1, 2, 3, 4, 5]
2.天然反轉排序：[5, 4, 3, 2, 1, null]
3.根據訂單ID天然排序：[Order(id=1, state=0), Order(id=2, state=2), Order(id=3, state=1)]
4.根據訂單ID天然排序,求最大值：Order(id=3, state=1)
5.根據訂單ID天然排序,求最小值：Order(id=1, state=0)
6.求ID最小的k個元素：[Order(id=1, state=0), Order(id=2, state=2)]
7.求ID最大的k個元素：[Order(id=3, state=1), Order(id=2, state=2)]

2.5 Throwables（不推薦使用）

 1.做用

異常支持，簡化了異常和錯誤的傳播與檢查。

2.簡單使用

目前JDK7已是比較老的版本了，JDK7自帶多重捕獲，7以及以上都不推薦使用Throwables，這裏就不寫使用了。

 3、總結

guava雖然很經典，可是由於JDK一直在迭代完善，當JDK中有的東西時，建議就不要用guava了。基礎工具中，Optional和Preconditions仍是能夠用用，其它的也就那樣了，各位本身看着用吧，固然做爲基礎工具，想要看guava源碼仍是有必要了解下知道是幹嗎的。

 

==參考==

Guava Github User Guide