Guava学习(一)-基础工具类

Preconditions

实际开发中需要做入参校验的情况比比皆是，比如开发一个rest接口，肯定要对参数各种校验，防止错误的输入导致程序出错。我们可以使用Preconditions(前置条件)，这样我们自己代码中就不会出现大段的if代码了。

    // bad practice
    public static void insert(String name, int age) {
        if (name == null || name.equals("")) {
            throw new IllegalArgumentException("name should not be empty.");
        }

        if (age <= 0) {
            throw new IllegalArgumentException("age should not be negative.");
        }
    }

如果入参很多，或者校验逻辑很复杂，这个函数中if会越来越多，圈复杂度越来越高。使用Preconditions就可以消除代码中的if了。

Guava在Preconditions类中提供了若干前置条件判断的实用方法，每个方法都有三个变种：

没有额外参数：抛出的异常中没有错误消息；
有一个Object对象作为额外参数：抛出的异常使用Object.toString() 作为错误消息；
有一个String对象作为额外参数，并且有一组任意数量的附加Object对象：这个变种处理异常消息的方式有点类似printf，但考虑GWT的兼容性和效率，只支持%s指示符。例如：
```
checkArgument(i >= 0, "Argument was %s but expected nonnegative", i)；
checkArgument(i < j, "Expected i < j, but %s > %s", i, j);
```

checkArgument(boolean) ：
　　功能描述：检查boolean是否为真。用作方法中检查参数
　　失败时抛出的异常类型: IllegalArgumentException
checkNotNull(T)：
　　功能描述：检查value不为null，直接返回value；
　　失败时抛出的异常类型：NullPointerException
checkState(boolean)：
　　功能描述：检查对象的一些状态，不依赖方法参数。
　　失败时抛出的异常类型：IllegalStateException
checkElementIndex(int index, int size)：
　　功能描述：检查index是否为在一个长度为size的list， string或array合法的范围。 index的范围区间是[0, size)。
　　失败时抛出的异常类型：IndexOutOfBoundsException
checkPositionIndex(int index, int size)：
　　功能描述：检查位置index是否为在合法的范围。 index的范围区间是[0， size]。
　　失败时抛出的异常类型：IndexOutOfBoundsException
checkPositionIndexes(int start, int end, int size)：
　　功能描述：检查[start, end)是一个长度为size的list， string或array合法的范围子集。0<=start<=end<=size。
　　失败时抛出的异常类型：IndexOutOfBoundsException

索引值常用来查找列表、字符串或数组中的元素，如List.get(int), String.charAt(int)
位置值和位置范围常用来截取列表、字符串或数组，如List.subList(int，int), String.substring(int)

Objects

equals

当一个对象中的字段可以为null时，实现Object.equals方法会很痛苦，因为不得不分别对它们进行null检查。使用Objects.equal帮助你执行null敏感的equals判断，从而避免抛出NullPointerException。例如:

Objects.equal("a", "a"); // returns true
Objects.equal(null, "a"); // returns false
Objects.equal("a", null); // returns false
Objects.equal(null, null); // returns true

hashCode

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

MoreObjects

firstNonNull

传入两个参数，返回第一个不是null的值，如果都是null，则抛出NullPointerException。

  public static <T> T firstNonNull(@Nullable T first, @Nullable T second) {
    if (first != null) {
      return first;
    }
    if (second != null) {
      return second;
    }
    throw new NullPointerException("Both parameters are null");
  }

toStringHelper

好的toString方法在调试时是无价之宝，但是编写toString方法有时候却很痛苦。使用 Objects.toStringHelper可以轻松编写有用的toString方法。例如:

// Returns "ClassName{x=1}"
Objects.toStringHelper(this).add("x", 1).toString();
// Returns "MyObject{x=1}"
Objects.toStringHelper("MyObject").add("x", 1).toString();

ComparisonChain

实现一个比较器[Comparator]，或者直接实现Comparable接口有时也伤不起。考虑一下这种情况：

class Person implements Comparable<Person> {
  private String lastName;
  private String firstName;
  private int zipCode;

  public int compareTo(Person other) {
    int cmp = lastName.compareTo(other.lastName);
    if (cmp != 0) {
      return cmp;
    }
    cmp = firstName.compareTo(other.firstName);
    if (cmp != 0) {
      return cmp;
    }
    return Integer.compare(zipCode, other.zipCode);
  }
}

这部分代码太琐碎了，因此很容易搞乱，也很难调试。我们应该能把这种代码变得更优雅，为此，Guava提供了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();
}

ComparisonChain执行一种懒比较：它执行比较操作直至发现非零的结果，在那之后的比较输入将被忽略。

Ordering

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

从实现上说，Ordering实例就是一个特殊的Comparator实例。Ordering把很多基于Comparator的静态方法（如Collections.max）包装为自己的实例方法（非静态方法），并且提供了链式调用方法，来定制和增强现有的比较器。

创建排序器

常见的排序器可以由下面的静态方法创建。

方法	描述
natural()	对可排序类型做自然排序，如数字按大小，日期按先后排序
usingToString()	按对象的字符串形式做字典排序[lexicographical ordering]
arbitrary()	返回一个所有对象的任意顺序，即compare(a, b) == 0 就是 a == b (identity equality)。本身的排序是没有任何含义，但是在VM的生命周期是一个常量。
from(Comparator)	把给定的Comparator转化为排序器

实现自定义的排序器时，除了用上面的from方法，也可以跳过实现Comparator，而直接继承Ordering：

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

链式调用方法

通过链式调用，可以由给定的排序器衍生出其它排序器。

方法	描述
reverse()	获取语义相反的排序器
nullsFirst()	使用当前排序器，但额外把null值排到最前面。
nullsLast()	使用当前排序器，但额外把null值排到最后面。
compound(Comparator)	合成另一个比较器，以处理当前排序器中的相等情况。
lexicographical()	基于处理类型T的排序器，返回该类型的可迭代对象Iterable的排序器。
onResultOf(Function)	对集合中元素调用Function，再按返回值用当前排序器排序。

例如，你需要下面这个类的排序器。

    class Foo {
        @Nullable 
        String sortedBy;
        int notSortedBy;
    }

考虑到排序器应该能处理sortedBy为null的情况，我们可以使用下面的链式调用来合成排序器：

Ordering<Foo> ordering = Ordering.natural().nullsFirst().onResultOf(new Function<Foo, String>() {
  public String apply(Foo foo) {
    return foo.sortedBy;
  }
});

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

注：用compound方法包装排序器时，就不应遵循从后往前读的原则。为了避免理解上的混乱，请不要把compound写在一长串链式调用的中间，你可以另起一行，在链中最先或最后调用compound。

超过一定长度的链式调用，也可能会带来阅读和理解上的难度。我们建议按下面的代码这样，在一个链中最多使用三个方法。此外，你也可以把Function分离成中间对象，让链式调用更简洁紧凑。

Ordering<Foo> ordering = Ordering.natural().nullsFirst().onResultOf(sortKeyFunction)

运用排序器

Guava的排序器实现有若干操纵集合或元素值的方法。

方法	描述
greatestOf(Iterable iterable, int k)	获取可迭代对象中最大的k个元素。
leastOf(Iterable iterable, int k)	获取可迭代对象中最小的k个元素。
isOrdered(Iterable)	判断可迭代对象是否已按排序器排序：允许有排序值相等的元素。
isStrictlyOrdered(Iterable)	是否严格有序：不允许有排序值相等的元素。
sortedCopy(Iterable)	返回排序列表的副本
immutableSortedCopy(Iterable)	返回不可变的排序副本
min(E, E)/max(E, E)	返回两个参数中最小/大的那个。如果相等，则返回第一个参数。
min(E, E, E, E…)/max(E, E, E, E…)	返回多个参数中最小/大的那个。如果有超过一个参数都最小/大，则返回第一个最小/大的参数。
min(Iterable)/max(Iterable)	返回迭代器中最小/大的元素。如果可迭代对象中没有元素，则抛出NoSuchElementException。

微笑看你哭

发布了44 篇原创文章 · 获赞 9 · 访问量 1万+

私信关注