guava（一）基本類

1. 在pom文件中引入Guava

<dependency>  
    <groupId>com.google.guava</groupId>  
    <artifactId>guava</artifactId>  
    <version>21.0</version>  
</dependency>  

1. 基本類

2.1 Optional

在Java中null既不是對象也不是實例，只是一個關鍵字。Optional就是對null的處理。

T Optional.of(T reference)

//Optional.of ---> 會檢測null 如果是null拋出異常。在of方法中調用了Preconditions.checkNotNull方法進行空值判斷 
Optional<Integer> num1 = Optional.of(value1);  

Optional Optional.fromNullable(T nullableReference)

//Optional.fromNullable --> 允許輸入爲空。但是在使用的時候要進行判斷  
Optional<Integer> num2 = Optional.fromNullable(value1);    
//如果num2不爲空。pres == true 否則 pres == false  
boolean pres = num2.isPresent();   

T orNull()

Optional<Integer> num3 = Optional.absent();   
//Optional.orNull --> 如果是null，就把null作爲值，否則返回num3的值    
System.out.println(num3.orNull());   

T or(Optional

T get()

//通過get方法獲取Optional對象的值
num1.get();

2.2 Preconditions

前置條件檢查，可以對表達式、布爾值進行檢查，檢查中可以輸出自定義異常信息，輸出被檢查的值
在Preconditions這個類中，checkArgument/checkState比較相似，checkElementIndex /checkPositionIndex比較相似

checkArgument/checkState方法

**void Preconditions.checkArgument(boolean expression)/checkState方法
void Preconditions.checkArgument(boolean expression，Object errorMessage)/checkState
void Preconditions.checkArgument(boolean expression, String errorMessageTemplate, Object.. errorMessageObjects)/checkState
void Preconditions.checkArgument(boolean expression, String errorMessageTemplate, Object ob1, Object ob2, Object ob3, Object ob4)/checkState**

//當name == null的時候，拋出異常，異常信息爲空 
Preconditions.checkArgument(name != null);  
//當name == test的時候，拋出異常，異常信息爲"this is a test" 
Preconditions.checkArgument(name != "test", "this is a test");  
//當age <= 0 || name == null 時，拋出異常，並在異常信息中輸出age， name對應的值  
Preconditions.checkArgument(age > 0 && name != null, "%s's age is %s is valid", name, age);  
//當age <= 0 || name == null 時，拋出異常，並在異常信息中輸出age， name對應的值。其他的，不能夠通過errorMessageTemplate格式化的參數，以數組形式，統一輸出 
Preconditions.checkArgument(age > 0 && name != null, "%s's age is %s is valid", name, age, 1,2,3,4,5,4,3,4,32);  

checkElementIndex/checkPositionIndex方法

**int Preconditions.checkElementIndex(int index, int size)/checkPositionIndex
int Preconditions.checkElementIndex(int index, int size, String desc)/checkPositionIndexes
void Preconditions.checkPositionIndexes(int start, int end, int size)**

// 前兩種方法時checkPositionIndexes、 checkElementIndex都有的方法，參數也是相同的
// index 要操作的索引，size 數組的大小 index>0 && index < size 返回index，否則拋出異常
int res = Preconditions.checkElementIndex(index, size);
// index 要操作的索引，size 數組的大小 index>0 && index < size 返回index，否則拋出異常,desc爲自定義異常信息
int res =  Preconditions.checkElementIndex(index, size, desc);

checkPositionIndex 只比 checkElementIndex 多了一個方法  
//start 開始index end 結束index size 集合大小  
// 如果start < 0  || end < start || end > size 拋出異常  
void Preconditions.checkPositionIndexes(int start, int end, int size)  

checkNotNull 方法

** T Preconditions.checkNotNull(T reference)
T Preconditions.checkNotNull(T reference, @Nullable Object errorMessage)
T Preconditions.checkNotNull(T reference, String errorMessageTemplate, Object… objects)
T Preconditions.checkNotNull(T reference, String errorMessageTemplate, Object ob1, Object ob2, Object ob3, Object ob4)**

//當name == null的時候，拋出異常，異常信息爲空 
Preconditions.checkArgument(name);  
//當name == null的時候，拋出異常，異常信息爲"this is a test" 
Preconditions.checkArgument(name, "this is a test");  
//name == null 時，拋出異常，並在異常信息中輸出age， name對應的值  
Preconditions.checkArgument(name, "name is null, age is %s", age);  
//name == null 時，拋出異常，並在異常信息中輸出age對應的值。其他的，不能夠通過errorMessageTemplate格式化的參數，以數組形式，統一輸出 
Preconditions.checkArgument(name, "name is null, age is %s", age, 1,2,3,4,5,4,3,4,32); 

2.3 Ordering

Ordering是Guava類庫提供的一個強大的比較器工具，它非常容易擴展，可以輕鬆構造複雜的comparator，然後用在容器的比較、排序等操作中。Ordering使用鏈式表達式，配合java8的lambda~~很不錯

返回一個排序器

// 生成一個對數據隨意排列的排序器
static Ordering<Object> arbitrary(); 
 // 生成一個數據按照自然序排列的排序器
static <C extends Comparable> Ordering<C> natural()  
// 所有數據地位相等，表明這個返回的是一個無排序的排序器
static Ordering<Object> allEqual()  
// 使用toString()返回的字符串按字典順序進行排序
static Ordering<Object> usingToString()  
// 生成一個按照指定方式排序的排序器
static <T> Ordering<T> from(Comparator<T> comparator)  

常用方法

// 返回一個將數據反轉的排序器。
<S extends T> Ordering<S> reverse()  
// 對數據進行二分查找，如果數據存在，返回索引，如果不存在，返回 -(low + 1)
int binarySearch(List<? extends T> sortedList, T key) 
// left<right return -1; left == right return 0; left>right return 1;
abstract int compare(T left, T right) 
//傳入集合由大到小排序，返回最大的k個元素
<E extends T> List<E> greatestOf(Iterable<E> iterable, int k) 
//傳入集合由小到大排序，返回最小的k個元素
<E extends T> List<E> leastOf(Iterable<E> iterable, int k)  
//按照當前的Ordering進行排序
<E extends T> List<E> sortedCopy(Iterable<E> iterable) 
// 判斷當前集合是否已經進行了排序
boolean isOrdered(Iterable<? extends T> iterable) 
// strictly ordered 嚴格排序，即排序集合中沒有相等的數據時纔會返回true
boolean isStrictlyOrdered(Iterable<? extends T> iterable) 
// 返回兩個數中的最大值
<E extends T> E max(E a, E b)  
//返回多個數中的最大值
<E extends T> E max(E a, E b, E c, E... rest)  
//返回集合中的最大值，若有多個，返回第一個
<E extends T> E max(Iterable<E> iterable) 
// 返回兩個數中的最小值
<E extends T> E min(E a, E b) 
//返回多個數中的最小值
<E extends T> E min(E a, E b, E c, E... rest) 
//返回集合中的最小值，若有多個，返回第一個
<E extends T> E min(Iterable<E> iterable) 
// 把空值放在首位
<S extends T> Ordering<S> nullsFirst() 
// 把空值放在末位
<S extends T> Ordering<S> nullsLast()  

例子

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import java.util.*;

/**
 * Guava Ordering
 *
 * @author Soul
 */
public class OrderingTest {

  private List<Integer> list_1 = new ArrayList<>(Arrays.asList(1, 0, 3, 4, 2, 1));
  private List<Integer> list_2 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9));
  private List<String> abc = ImmutableList.of("a", "b", "c");//創建一個不可變集合
  private List<Integer> comparator_test = new ArrayList<>(Arrays.asList(-2, 1, 4, 3, 5, -9, -1));

  public static void main(String[] args) {
    OrderingTest test = new OrderingTest();
    Ordering ordering = Ordering.natural();
    test.binarySearchTest(ordering);
    test.compareTest(ordering);
    test.isSortedTest(ordering);
    test.reverseTest(ordering);
    test.maxMinTest(ordering);
    test.otherMethodTest(ordering);
    test.useComparatorTest(ordering);
    test.sortedSet();
  }

  /**
   * ordering.binarySearch(sortedList, key); attention to sortedList
   *
   * list_1 = ordering.sortedCopy(list_1);
   */
  private void binarySearchTest(Ordering ordering) {
    list_1 = ordering.sortedCopy(list_1);
    System.out.println("sorted copy ：" + list_1);
    System.out.println("is strictly sorted list_1： " + ordering.isStrictlyOrdered(list_1));//false
    int res = ordering.binarySearch(list_1, 5);
    System.out.println("binary search ：" + res);
  }

  private void compareTest(Ordering ordering) {
   int res = ordering.compare(1, 2);
    System.out.println("compare two parameters：" + res);

    res = ordering.compare(2, 2);
    System.out.println("compare two parameters：" + res);

    res = ordering.compare(3, 2);
    System.out.println("compare two parameters：" + res);
  }

  /**
   * 判斷集合是否已經排序
   */
  private void isSortedTest(Ordering ordering) {
    System.out.println("sorted test ：" + ordering.isOrdered(list_2));//true
    System.out.println("strictly sorted test ：" + ordering.isStrictlyOrdered(list_2));
  }

  /**
   * reverse
   */
  private void reverseTest(Ordering ordering) {
    System.out.println("test list_2 reverse :" + ordering.reverse().sortedCopy(list_2));
    System.out.println("isOrdered reverse :" + ordering.reverse().isOrdered(abc));
  }

  /**
   * max min
   */
  private void maxMinTest(Ordering ordering) {
    System.out.println("max :" + ordering.max(abc));
    System.out.println("min :" + ordering.min(abc));
  }

  /**
   * ImmutableSortedSet
   */
  private void sortedSet() {
    Set<String> imSortList = ImmutableSortedSet.of("a", "b", "c", "a", "d", "b");
    System.out.println("imSortSet：" + imSortList);
  }

  private void otherMethodTest(Ordering ordering) {

    System.out.println("leastOf:" + ordering.leastOf(list_2, 2));
    System.out.println("greatestOf:" + ordering.greatestOf(list_2, 3));
    System.out.println("reverse list_2 :" + ordering.reverse().sortedCopy(list_2));
    list_2.add(null);
    System.out.println("add null list_2:" + list_2);
    System.out.println("nullsFirst list_2 :" + ordering.nullsFirst().sortedCopy(list_2));
    System.out.println("nullsLast list_2 :" + ordering.nullsLast().sortedCopy(list_2));
  }

  /**
   * 對ordering使用自定義排序器
   */
  private void useComparatorTest(Ordering ordering) {
    Comparator<Integer> comparator = (Integer o1,Integer o2)->(o1.compareTo(o2));
    System.out.println("comparator test: " + Ordering.from(comparator).sortedCopy(comparator_test));
  }
}

sorted copy ：[0, 1, 1, 2, 3, 4]
is strictly sorted list_1： false
binary search ：-7
compare two parameters：-1
compare two parameters：0
compare two parameters：1
sorted test ：true
strictly sorted test ：true
test list_2 reverse :[9, 8, 7, 6, 5, 4, 3, 2, 1]
isOrdered reverse :false
max :c
min :a
leastOf:[1, 2]
greatestOf:[9, 8, 7]
reverse list_2 :[9, 8, 7, 6, 5, 4, 3, 2, 1]
add null list_2:[1, 2, 3, 4, 5, 6, 7, 8, 9, null]
nullsFirst list_2 :[null, 1, 2, 3, 4, 5, 6, 7, 8, 9]
nullsLast list_2 :[1, 2, 3, 4, 5, 6, 7, 8, 9, null]
comparator test: [-9, -2, -1, 1, 3, 4, 5]
imSortSet：[a, b, c, d]

對binarySearch進行說明： binary search ：-7

[0, 1, 1, 2, 3, 4]爲排序結果，我們要查找的是5.  
第一次low = 0，high = 5. mid = 2, 查到1<5.low = mid+1 = 3
第二次low = 3, high = 5, mid = 4, 查到3<5.low = mid+1 = 5  
第三次low = 5, high = 5, mid = 5, 查到4<5.low = mid+1 = 6
第四次low > high,結束循環，返回 -(low+1) = -7