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