（一）Optional
//返回指定引用的Optional实例，若指定引用为null，抛出NullPointerException Optional<Integer> optional1 = Optional.of(5); Optional<Object> optional2 = Optional.of(null); //抛出NullPointerException //返回引用缺失的Optional实例 Optional<Object> optional3 = Optional.absent(); //返回指定引用的Optional实例，引用可以为null Optional<Integer> optional4 = Optional.fromNullable(5); Optional<Object> optional5 = Optional.fromNullable(null); //判断Optional中是否包含非null的引用，如果有返回true boolean present1 = optional1.isPresent(); //true boolean present3 = optional3.isPresent(); //false boolean present4 = optional4.isPresent(); //true boolean present5 = optional5.isPresent(); //false //返回Optional中的引用，若没有非null的引用抛出IllegalStateException Integer get1 = optional1.get(); //5 Object get2 = optional3.get(); //抛出IllegalStateException //返回Optional中的引用，若没有非null的引用则返回指定引用 Integer or1 = optional1.or(6); //5 Object or2 = optional3.or(6); //6 //返回Optional中的引用，若没有非null的引用则返回null Integer orNull1 = optional1.orNull(); //5 Object orNull2 = optional3.orNull(); //null //返回Optional中的引用成一个只有单一元素set，若没有非null的引用则返回空set Set<Integer> integers = optional1.asSet(); Set<Object> objects = optional3.asSet();
（二）Preconditions
//检查一个boolean是否为true，若不是，抛出IllegalArgumentException，并且可以指定异常描述 Preconditions.checkArgument(true); Preconditions.checkArgument(false); //抛出IllegalArgumentException Preconditions.checkArgument(false,"校验失败"); //抛出IllegalArgumentException：校验失败 //检查value是否为null，并且返回value，若value为null抛出IllegalArgumentException，并且可以指定异常描述 Integer integer = Preconditions.checkNotNull(5); //5 Object o1 = Preconditions.checkNotNull(null); //抛出NullPointerException Object o2 = Preconditions.checkNotNull(null, "值为空"); //抛出NullPointerException：值为空 Object o2 = Preconditions.checkNotNull(null, "值为空，应该是%s", 5); //抛出NullPointerException：值为空，应该是5 //检查一个boolean的状态是否为true，若不是，抛出IllegalStateException，并且可以指定异常描述 Preconditions.checkState(true); Preconditions.checkState(false); //抛出IllegalStateException Preconditions.checkState(false,"状态错误"); //抛出IllegalStateException：状态错误 //检查index做为索引是否满足：index >= 0 && index < size，若满足返回index，不满足则抛出IndexOutOfBoundsException，并且可以指定异常描述 int index1 = Preconditions.checkElementIndex(1, 2); //1 int index2 = Preconditions.checkElementIndex(2, 2); //抛出IndexOutOfBoundsException int index3 = Preconditions.checkElementIndex(2, 2,"超出范围"); //抛出IndexOutOfBoundsException: 超出范围 //检查index作为位置是否满足：index >= 0 && index <= size，若满足返回index，不满足则抛出IndexOutOfBoundsException，并且可以指定异常描述 int index4 = Preconditions.checkPositionIndex(2, 2); //2 int index5 = Preconditions.checkPositionIndex(3, 2); //抛出IndexOutOfBoundsException int index6 = Preconditions.checkPositionIndex(3, 2,"超出范围"); //抛出IndexOutOfBoundsException: 超出范围 //检查start end是否满足：start >= 0 && start <= end && end <= size，不满足则抛出IndexOutOfBoundsException Preconditions.checkPositionIndexes(1, 5,5); Preconditions.checkPositionIndexes(1, 6,5); //抛出IndexOutOfBoundsException Preconditions.checkPositionIndexes(-1, 3,5); //抛出IndexOutOfBoundsException
源码：
public static void checkArgument(boolean expression, @Nullable Object errorMessage) { if (!expression) { throw new IllegalArgumentException(String.valueOf(errorMessage)); } } public static <T> T checkNotNull(T reference, @Nullable Object errorMessage) { if (reference == null) { throw new NullPointerException(String.valueOf(errorMessage)); } return reference; } public static void checkState(boolean expression, @Nullable Object errorMessage) { if (!expression) { throw new IllegalStateException(String.valueOf(errorMessage)); } } public static int checkElementIndex(int index, int size, @Nullable String desc) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(badElementIndex(index, size, desc)); } return index; } public static int checkPositionIndex(int index, int size, @Nullable String desc) { // Carefully optimized for execution by hotspot (explanatory comment above) if (index < 0 || index > size) { throw new IndexOutOfBoundsException(badPositionIndex(index, size, desc)); } return index; } public static void checkPositionIndexes(int start, int end, int size) { if (start < 0 || end < start || end > size) { throw new IndexOutOfBoundsException(badPositionIndexes(start, end, size)); } }
（三） Ordering
import com.google.common.collect.Ordering; import com.google.common.primitives.Ints; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class OrderingTest { public static void main(String args[]) { List<Integer> list = new ArrayList<>(); list.add(new Integer(5)); list.add(new Integer(3)); list.add(new Integer(4)); list.add(new Integer(1)); list.add(new Integer(2)); //对可排序类型做自然排序，如数字按大小，日期按先后排序 Ordering ordering = Ordering.natural(); System.out.println(list); //[5, 3, 4, 1, 2] Collections.sort(list, ordering); System.out.println(list); //[1, 2, 3, 4, 5] //判断对象是否按排序器排序，允许有相等元素 System.out.println(ordering.isOrdered(list)); //true //返回最小元素，如果对象中没有元素，则抛出NoSuchElementException System.out.println(ordering.min(list)); //1 //返回最大元素，如果对象中没有元素，则抛出NoSuchElementException System.out.println(ordering.max(list)); //5 //获取可迭代对象中最大的k个元素 System.out.println(ordering.greatestOf(list, 3)); //[5, 4, 3] //获取可迭代对象中最小的k个元素 System.out.println(ordering.leastOf(list, 3)); //[1, 2, 3] //获取相反的排序器 Collections.sort(list, ordering.reverse()); System.out.println(list); //[5, 4, 3, 2, 1] list.add(null); System.out.println(list); //[5, 4, 3, 2, 1, null] //使用当前排序器，但把null排到最前面 Collections.sort(list, ordering.nullsFirst()); System.out.println(list); //[null, 1, 2, 3, 4, 5] List<String> strings = new ArrayList<>(); strings.add("dd"); strings.add("aaa"); strings.add("cccc"); strings.add(null); strings.add("b"); System.out.println(strings); //[dd, aaa, cccc, null, b] //按对象的字符串形式做字典排序 Ordering<Object> usingToStringOrdering = Ordering.usingToString(); Collections.sort(strings, usingToStringOrdering.nullsFirst().reverse()); System.out.println(strings); //[dd, cccc, b, aaa, null] //把给定的Comparator转化为排序器 Ordering<String> fromOrdering = Ordering.from(new Comparator<String>() { @Override public int compare(String s1, String s2) { return Ints.compare(s1.length(), s2.length()); } }); Collections.sort(strings, fromOrdering.nullsFirst().reverse()); System.out.println(strings); //[cccc, aaa, dd, b, null] } }
（四）Objects
import com.google.common.base.MoreObjects; import com.google.common.base.Objects; import com.google.common.collect.ComparisonChain; class Student implements Comparable<Student> { private String name; private int age; private String address; public Student(String name, int age, String address) { this.name = name; this.age = age; this.address = address; } @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null) { return false; } Student student = (Student) object; return Objects.equal(this.name, student.name) && Objects.equal(this.age, student.age) && Objects.equal(this.address, student.address); } @Override public int hashCode() { return Objects.hashCode(name, age, address); } @Override public String toString() { return MoreObjects.toStringHelper(this).omitNullValues() .add("name", this.name) .add("age", this.age) .add("address", this.address).toString(); } @Override public int compareTo(Student s) { return ComparisonChain.start() .compare(this.name, s.name) .compare(this.age, s.age) .compare(this.address, s.address) .result(); } }