Guava学习-官方笔记第一章

Optional

主要就是提醒编码者注意处理引用缺失的情况

Guava 用 Optional表示可能为 null 的 T 类型引用。一个 Optional 实例可能包含非 null 的引用（我们**称之为引
用存在），也可能什么也不包括（称之为引用缺失**）。它从不说包含的是 null 值，而是用存在或缺失来表示。但
Optional 从不会包含 null 值引用

创建Optional实例（静态方法）

• Optional.of(T) 创建指定引用的 Optional 实例，若引用为 null 则快速失败
• Optional.absent() 创建引用缺失的 Optional 实例
• Optional.fromNullable(T) 创建指定引用的 Optional 实例，若引用为 null 则表示缺失

@Test
    public void test1() {
        Optional<Integer> possible = Optional.of(5);
        possible.isPresent(); // returns true
        possible.get(); // returns 5,，引用缺失的话，会直接抛出错误
        boolean flag = (5 == possible.get()) ? true : false;
        Assert.assertEquals("ok", true, flag);

        Foo f = null;

        Optional<Foo> tmp = Optional.fromNullable(f);//创建optional

        System.out.println(tmp.or(new Foo("3",3)));//引用缺失，直接返回new Foo("3",3)

    }

Preconditions前置条件

Guava 在 Preconditions 类中提供了若干前置条件判断的实用方法每个方法都有三个变种：
- 没有额外参数：抛出的异常中没有错误消息；
- 有一个 Object 对象作为额外参数：抛出的异常使用 Object.toString() 作为错误消息；
- 有一个 String 对象作为额外参数，并且有一组任意数量的附加 Object 对象：这个变种处理异常消息的方式
有点类似 printf，但考虑 GWT 的兼容性和效率，只支持%s 指示符。

@Test
    public void test7() {
        String name ="whp404";
        try {
            Preconditions.checkArgument(name.length()<5, "failure %s message", name);
        }catch(Exception e) {
            System.out.println(e.getMessage());
        }
    }

    打印结果：
    failure whp404 message 

常见Object方法

• equals
  使用 Objects.equal 帮助你执行 null 敏感的 equals 判断，从而避免抛出 NullPointerException。

import org.junit.Test;
import com.google.common.base.Objects;

public class ObjectTest {

    @Test
    public void equalTest() {
        System.out.println(Objects.equal("a", "a"));
        System.out.println(Objects.equal(null, "a")); 
        System.out.println(Objects.equal("a", null)); 
        System.out.println(Objects.equal(null, null));
    }

    @Test
    public void equalPersonTest() {
        System.out.println(Objects.equal(new Person("peida",23), new Person("peida",23)));
        Person person=new Person("peida",23);
        System.out.println(Objects.equal(person,person));
    }
}

class Person {
    public String name;
    public int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

• hashcode

  用对象的所有字段作散列[hash]运算应当更简单。Guava 的 Objects.hashCode(Object…)会对传入的字段序
  列计算出合理的、顺序敏感的散列值。你可以使用 Objects.hashCode(field1, field2, …, fieldn)来代替手动计算
  散列值。

• toString

使用 Objects.toStringHelp
er 可以轻松编写有用的 toString 方法，我找到貌似只能用MoreObjects，我的环境是guava 26.0-jre

    @Test
    public void test3() {

        System.out.println(MoreObjects.toStringHelper(this).add("x", 1).toString());
        System.out.println(MoreObjects.toStringHelper(Person.class).add("x", 1).toString());

        Person person = new Person("peida", 23);
        String result = MoreObjects.toStringHelper(Person.class).add("name", person.name).add("age", person.age)
                .toString();
        System.out.print(result);
    }


    结果显示：
    GuavaTest{x=1}
    Person{x=1}
    Person{name=peida, age=23}

### compare/compareTo方法

帮助我们编写compare方法

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();
}

Ordering排序

排序器[Ordering]是 Guava 流畅风格比较器[Comparator]的实现，它可以用来为构建复杂的比较器，以完成集
合排序的功能。
从实现上说，Ordering 实例就是一个特殊的 Comparator 实例

自定义的ordering实例，类似自定义comparator

Ordering<String> byLengthOrdering = new Ordering<String>() {
public int compare(String left, String right) {
return Ints.compare(left.length(), right.length());
}
};

静态创建排序器的分子

• natural() 对可排序类型做自然排序，如数字按大小，日期按先后排序
• usingToString() 按对象的字符串形式做字典排序[lexicographical ordering]
• from(Comparator) 把给定的 Comparator 转化为排序器

需要注意的是，阅读链式调用产生的排序器时，应该从后往前读。上面的例子中，排序器首先调用 apply 方法获取 sortedBy
值，并把 sortedBy 为 null 的元素都放到最前面，然后把剩下的元素按 sortedBy 进行自然排序。之所以要从后
往前读，是因为每次链式调用都是用后面的方法包装了前面的排序器。

@Test
    public void test4() {
        //创建了order排序器
        Ordering<Foo> order = Ordering.natural().nullsFirst().onResultOf(new Function<Foo, String>() {

            @Override
            public @Nullable String apply(@Nullable Foo input) {
                // TODO Auto-generated method stub
                return input.sortby;
            }
        });

        List<Foo> list = new ArrayList<>();
        Random dom = new Random();
        for (int i = 0; i < 10; i++) {

            Foo f = new Foo(dom.nextInt(100) + "", dom.nextInt(200));
            list.add(f);
        }
        // List<Foo> leastOf = order.leastOf(list, 10);

        List<Foo> leastOf = order.leastOf(list, 5);//返回最小的五个foo实例

        System.out.println(leastOf);
    }

简化异常处理的Throwables

Guava提供了一个异常处理工具类, 可以简单地捕获和重新抛出多个异常。这个工具就是Throwables。借助Throwables工具类，我们可以很轻松地完成以下一些事情：

• 获取异常链
• 获取最底层的异常
• 过滤异常，只抛出我们感兴趣的异常

@Test
public void testPropagrateIfInstanceOf() throws IOException {
    try {
        throw new IOException();
    } catch (Throwable t) {
        Throwables.propagateIfInstanceOf(t, NullPointerException.class);
        System.out.println("Hello World!");
    }
}

• 把受检查的异常转换为运行时异常

@Test
public void testThrowablesPropagate() {
    try {
        throw new Exception();
    } catch (Throwable t) {
        String messages = Throwables.getStackTraceAsString(t);
        System.out.println("messages: " + messages);
        Throwables.propagate(t); // RuntimeException
    }
}

Guava 提供了如下三个有用的方法，让研究异常的原因链变得稍微简便了
- Throwable getRootCause(Throwable)
- List getCausalChain(Throwable
- String getStackTraceAsString(Throwable)