guava笔记1-Optional，Preconditions，Ordering，Objects，ComparisonChain，Throwables

 （1）Optional  标识可以为空的对象。
   static <T> Optional<T> absent() 返回事实上的空对象。
   static <T> Optional<T> of(T reference) 构造一个Optional对象。注意T不能为null，否则将抛异常。
   static <T> Iterable<T> presentInstances(Iterable<? extends Optional<? extends T>> optionals) 从一个Iterable构造另一个Iterable，除去空对象（isPresent()=true）

   abstract boolean isPresent() 返回是否为空。
   abstract T get() 返回存储的对象。
   abstract Set<T> asSet() 返回一个集合，仅包含存储的对象一个元素，如果为空的话就是空集合。
   abstract Optional<T>    or(Optional<? extends T> secondChoice)返回对象，如果为空就返回secondChoice。
   abstract T or(Supplier<? extends T> supplier) 返回对象，如果为空就返回supplier.get()返回的对象；Supplier是个很简单的接口，只有get()一个方法；这样的话各种实现该接口的对象都可以提供Optional的默认值。
   abstract T or(T defaultValue)返回对象，为空则返回defaultValue
   abstract T orNull() 返回对象，为空则返回null
   abstract <V> Optional<V> transform(Function<? super T,V> function) 将Optional对象转化为V对象
  
   equals，hashcode，tostring就不说了。

 （2）Preconditions 断言， 这个用的比较多。一般用于校验方法传入的参数是否满足心理预期。
  checkArgument(i >= 0, "Argument was %s but expected nonnegative", i);
  checkArgument(i < j, "Expected i < j, but %s > %s", i, j);

  主要的方法有：
  checkArgument(boolean)
  checkNotNull(T)
  checkState(boolean)
  checkElementIndex(int index, int size)
  checkPositionIndex(int index, int size)
  checkPositionIndexes(int start, int end, int size)

  （3）Ordering 对集合进行排序，是guava对comparators的优化，实现了接口Comparator<T>，支持标准的链式操作。
static Ordering<Object>    allEqual()  返回的排序策略认为所有对象都是相等的，包括null。
Ordering.allEqual().nullsLast().sortedCopy(asList(t, null, e, s, null, t, null)) 将把null往后放，其他的维持原顺序。

static Ordering<Object>    arbitrary() 跟Comparator类似，这种排序方式下，看compare方法返回的结果。
static <T> Ordering<T>    compound(Iterable<? extends Comparator<? super T>> comparators)
  返回一种排序策略，依次使用comparators来比较，如果某个comparator比较的结果为相等，则用下一个，否则直接返回这个比较结果。
  这个类似于sql里面的order by column1，column2,...
static <T> Ordering<T>    explicit(List<T> valuesInOrder) 返回一种排序策略，主要看元素在valuesInOrder中出现的次序。
static <T> Ordering<T>    explicit(T leastValue, T... remainingValuesInOrder)  等价于explicit(Lists.asList(leastValue, remainingValuesInOrder)); 把最小的一个元素单独作为参数了

static <T> Ordering<T>    from(Comparator<T> comparator)  将comparator转换为Ordering
static <C extends Comparable> Ordering<C> natural() 返回自然排序这种排序策略
static Ordering<Object>    usingToString() 使用toString()返回的结果进行自然排序

int binarySearch(List<? extends T> sortedList, T key) 采用二分查找算法查找元素，排序算法就是Ordering指定的
abstract int compare(@Nullable T left, @Nullable  T right) 比较2个对象，Ordering的排序就是靠这个
<U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator) 跟static方法compound类似，会先用this排序来比较，如果比较结果相等，则用secondaryComparator再来比
<S extends T> Ordering<Iterable<S>> lexicographical() 按词典序比较两个Iterable对象的大小，谁元素多谁大，元素个数相同则看谁前面的元素大

<E extends T> List<E>    greatestOf(Iterable<E> iterable, int k)  返回第k大的元素，使用本排序规则,k从0计数
<E extends T> List<E>    greatestOf(Iterator<E> iterator, int k)  同上
同样的还有同上的leastOf方法 返回第k小的元素

<S extends T> Ordering<S> nullsFirst() 在原有排序规则上新加规则：null值排最前面
<S extends T> Ordering<S> nullsLast() 在原有排序规则上新加规则：null值排最后面

<F> Ordering<F>    onResultOf(Function<F,? extends T> function) 先用function转换对象，再用本规则来排序
<S extends T> Ordering<S> reverse() 将原排序规则倒序
<E extends T> List<E> sortedCopy(Iterable<E> iterable) 排序后的结果copy一份返回
<E extends T> ImmutableList<E> immutableSortedCopy(Iterable<E> iterable) 排序后的结果copy一份不可变的list返回

boolean    isOrdered(Iterable<? extends T> iterable) 比较是否有序，即compare(prev, next)<=0
boolean    isStrictlyOrdered(Iterable<? extends T> iterable) 比较是否严格有序，即compare(prev, next)<0

<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 max(Iterator<E> iterator)  返回最大的元素，使用本排序规则
同样的还有同上的min方法

(4) Objects里面的方法：equal，hashCode，ToStringHelper 
 我们都知道java.lang.Object里面有下面几个抽象方法：equals，hashCode，toString。
 guava里面提供了方法帮我们快速实现这些抽象方法。

 static boolean    equal(Object a, Object b) 判空了
 static int hashCode(Object... objects) 计算hashcode，底层其实调用了Arrays.hashCode
 static class ToStringHelper  帮助生成可读性好的toString字符串，一般会包含class的name以及各个成员的值
 static Objects.ToStringHelper    toStringHelper(Class<?> clazz) 返回ToStringHelper对象，clazz是对象的类型
 static Objects.ToStringHelper    toStringHelper(Object self)  返回ToStringHelper对象，self.getClass会作为对象的类型
 static Objects.ToStringHelper    toStringHelper(String className) 返回ToStringHelper对象，className是对象的类型
 代码示例：Objects.toStringHelper(this).add("x", "aaa")
 说明：ToStringHelper好像没有使用反射自动获取各个成员的值，需要自己手动add？

 （5）ComparisonChain.compareTo

   如果对象实现了Comparable接口，我们需要实现compare方法来比较两个对象的大小。
 ComparisonChain提供了快速方法帮助我们简化这个代码。
    public int compareTo(Foo that) {
     return ComparisonChain.start()
         .compare(this.aString, that.aString)
         .compare(this.anInt, that.anInt)
         .compare(this.anEnum, that.anEnum, Ordering.natural().nullsLast())
         .result();
   }
   可以看到，我们用了3次比较来确定this和that的大小。如果aString已经有结果了，后面就不会执行了。
   compare有很多重载的版本，用于比较各种类型值的大小。布尔值的比较比较特殊，可以用下面的方法比较：
   compareFalseFirst(boolean left, boolean right) 用来比较boolean值的大小， false的小一些。
   compareTrueFirst(boolean left, boolean right) 用来比较boolean值的大小， true的小一些。
   其实，guava更推荐我们使用Ordering来比较对象大小，而不是自己实现Comparable接口。


   (6) Throwables 处理异常
   Throwables类提供了一些静态工具方法，帮我们更好的处理异常。
   static List<Throwable> getCausalChain(Throwable throwable) 以list的方式得到throwable的异常链
   static Throwable getRootCause(Throwable throwable) 返回最底层的异常
   static String getStackTraceAsString(Throwable throwable) 返回printStackTrace的结果string

   有时候，我们捕获到异常后，只会对感兴趣的异常重新抛出，其他的异常就抛出RuntimeException好了。
   和Java 7的 multi-catch and rethrow类似。
   try {
     someMethodThatCouldThrowAnything();
   } catch (IKnowWhatToDoWithThisException e) {
     handle(e);
   } catch (Throwable t) {
     Throwables.propagateIfInstanceOf(t, IOException.class);
     Throwables.propagateIfInstanceOf(t, SQLException.class);
     throw Throwables.propagate(t);
   }

   static <X extends Throwable> void propagateIfInstanceOf(Throwable throwable, Class<X> declaredType) 如果throwable是declaredType类型的异常，则抛出declaredType的异常
   static void propagateIfPossible(Throwable throwable)  如果throwable是Error或者RuntimeException的异常，则抛出Error或者RuntimeException的异常
   static RuntimeException propagate(Throwable throwable) 如果throwable是Error或者RuntimeException的异常，则抛出Error或者RuntimeException的异常，否则也会强行抛出RuntimeException的异常。这个方法返回RuntimeException，其实永远不会，只是为了可以写成throw propagate(throwable),让编译器认为确实throw了。
   static <X extends Throwable> void propagateIfPossible(Throwable throwable, Class<X> declaredType) 如果throwable是declaredType类型的异常，则抛出declaredType的异常;否则，如果throwable是Error或者RuntimeException的异常，则抛出Error或者RuntimeException的异常
   static <X1 extends Throwable,X2 extends Throwable> void propagateIfPossible(Throwable throwable, Class<X1> declaredType1, Class<X2> declaredType2) 跟上个方法类似，不过会先检查declaredType1和declaredType2两种异常，否则再判断Error或者RuntimeException