guava--应用篇（三）Ordering 和异常处理 Throwables

Ordering: guava对比较器的扩展

         在java中进行类的排序大小比较，需要实现comparable接口 也就是内部比较器， 或者 使用外部比较器Comparator,

 定义一个book类，实现了comoparable接口

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book implements Comparable<Book> {
    
    private String bookName;
    private Double price;
    private String author;
    private Date createDate;

    @Override
    public int compareTo(Book b2) {
        return Double.compare(price,b2.getPrice());
    }
}

初始化几个集合

    private List<Book> books;
    private List<String> strings;
    private List<Integer> integers;

    @Before
    public void initList() {
        books = Lists.newArrayList();
        books.add(new Book("java1234",9.9,"java",new Date()));
        books.add(new Book("python1234",10.9,"python",new Date()));
        books.add(new Book("scala1234",8.9,"scala",new Date()));
        books.add(new Book("c++1234",14.9,"c++",new Date()));
        integers = Lists.newArrayList(2, 9, 8, 1);
        strings = Lists.newArrayList("zhangsan", "lisi", "wangwu");
    }

代码示例：

1. 构建Ordering

    Ordering.natural();

     Ordering.usingToString();

    Ordering.from(comparator);

    Ordering.compound(Iterable<comparator>)

        /**构建 ordering**/
//        natural,返回使用值的自然顺序进行比较的ordering实例
        Ordering<Comparable> natural = Ordering.natural();

//        usingToString, 返回对象的tostring后的字符串形式进行比较的ordering实例
        Ordering<Object> objectOrdering = Ordering.usingToString();

//         from， 返回基于现有的comarator 的ordering
        Ordering<Book> fromOrdering = Ordering.from(Comparator.comparing(Book::getAuthor));

//        compound， 返回带有多个比较器的排序规则，比如按照bookName排序，bookName相同的则按照price
        Ordering<Book> compound1 = Ordering.compound(Lists.newArrayList(
                Comparator.comparing(Book::getBookName),
                Comparator.comparing(Book::getPrice)));

2. ordering 的实例方法和链式调用组合多个排序规则

    onResultOf(Function<F,? extends T> function)

       Ordering<Comparable> natural = Ordering.natural();
//        onResultOf ;排序前先应用一个function的结果 进行排序，下面就是按照bookName排序的，并么按照book
//        中自己实现的comparable的排序
        Ordering<Book> bookOrdering = natural.onResultOf(new Function<Book, Comparable>() {
            @Override
            public Comparable apply(@Nullable Book book) {
                return book.getBookName();
            }
        });
        List<Book> books = bookOrdering.sortedCopy(this.books);
       books.forEach(book -> System.out.println(book.getBookName() +" == " + book.getPrice()));
//       输出结果，按照名称排序
//        c++1234 == 9.9
//        java12345 == 10.9
//        java12345 == 9.9
//        scala1234 == 10.2

 其他实例方法

 @Test
    public void testorderingSort() {
        Ordering<Comparable> natural = Ordering.natural();
//        max()最大
        System.out.println(natural.max(1, 3, 2)); //3
//        min()最小
        System.out.println(natural.min(1,5,0));  //0
//        leastOf(Iterable<E> iterable, int k)
//        返回k个最小元素，从小到大
        System.out.println(natural.leastOf(Lists.newArrayList(1,7,2,4,6,3),3)); // [1,2,3]
//        greatestOf(Iterable<E> iterable, int k)
//        返回k个组大元素，从大倒下
        System.out.println(natural.greatestOf(Lists.newArrayList(1,7,2,4,6,3),3)); // [7,6,4]
//        isOrdered(Iterable<? extends T> iterable), 判断是否是排好序的集合
        System.out.println(natural.isOrdered(Lists.newArrayList(1,23,2))); // false
//         nullsFirst(), 视为null为最小的
        System.out.println(natural.nullsFirst().min(null,1));  // null
//        nullsLast(),  是为null 为最大
        System.out.println(natural.nullsLast().max(null,1));   // null
//        reverse(), 反转排序
        System.out.println(natural.nullsLast().reverse().max(null,1));  // 1
//        sortedCopy, 返回一个拍好序的可变List
        natural.sortedCopy(Lists.newArrayList(1,2,5,4,3)).forEach(System.out::print); //12345

    }

 

Throwables

 这个用的不多 ，可以参考找个：http://ifeve.com/google-guava-throwables/