Guava的实践之基础工具

相信大多java开发的同学都使用过Guava这个库，Gauva是谷歌开源的java核心工具库，其中包含：集合，缓存，并发，字符串，I/O和验证相关的支持。下面我们就开始Guava的实践吧。

使用的Guava包版本

       <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>27.1-jre</version>
        </dependency>

1.null值的安全处理

import com.google.common.base.Optional;

public class GuavaMain {

    /**
     * null值的安全处理
     */
    private static void nullTest() {
        //fromNullable()允许传入null作为参数
        Optional s1 = Optional.fromNullable(null);

        //of()要求参数一定不能为null
        Optional s2 = Optional.of("hello");

        System.out.println(s2.get());
    }

    /**
     * 主函数
     * @param args
     */
    public static void main(String[] args) {
        nullTest();
    }
}

使用过jdk8的同学其实可以很快想到它的新特性Optional，其实jdk8的Optional是在guava的基础上做了更强大的扩展，功能更加丰富强大。感兴趣的同学可以参考我的另一篇博客java8新特性之Optional,里面有对jdk8新特性Optional的相关实践。

2.Preconditions前置条件判断

import com.google.common.base.Preconditions;

public class GuavaMain {

    /**
     * 参数检测
     */
    private static void preconditionsTest() {
        int age = 200;
        //只有第一个表达式返回true才能正常通过，否则抛异常
        Preconditions.checkArgument(age > 0 && age < 150, "不合理的年龄:%s", age);

        int[] nums = new int[10];
        int index = 11;
        //只有index>=0 && index<nums.length才能通过
        Preconditions.checkElementIndex(index, nums.length);
        //同上
        Preconditions.checkPositionIndex(index, nums.length);
        //只有当start和end参数都处于size范围内才通过
        Preconditions.checkPositionIndexes(-1, 11, nums.length);

        Object obj = null;
        //只有obj不为null才通过
        Preconditions.checkNotNull(obj);

        //假设active是一个用户激活状态
        boolean active = false;
        Preconditions.checkState(active, "用户未激活");
    }

    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        preconditionsTest();
    }
}

3.Ordering排序器
Ordering实现自Comparator，也就是说，Ordering是专门用来定义各种排序规则的。

import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import com.google.common.primitives.Ints;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class GuavaMain {

    /**
     * 排序器
     */
    private static void orderingTest() {
        /**
         * nullsFirst()
         */
        List<Integer> toSort = Arrays.asList(3, 5, 4, null, 1, 2);
        //先把null值放在最前面，再把非null值按照自然排序
        Collections.sort(toSort, Ordering.natural().nullsFirst());
        Preconditions.checkState(toSort.get(0) == null);


        /**
         * nullsLast()
         */
        List<Integer> toSort = Arrays.asList(3, 5, 4, null, 1, 2);
        //先把null值放在最后，再把非null值按照自然排序
        Collections.sort(toSort, Ordering.natural().nullsLast());
        Preconditions.checkState(toSort.get(toSort.size() - 1) == null);


        /**
         * natural()
         */
        List<Integer> toSort = Arrays.asList(3, 5, 4, 1, 2);
        //自然排序
        Collections.sort(toSort, Ordering.natural());
        //判断该集合是否已经按照指定排序器排序
        Preconditions.checkState(Ordering.natural().isOrdered(toSort));


        /**
         * 自定义一个根据字符串长度排序的排序器
         */
        class OrderingByLenght extends Ordering<String> {
            @Override
            public int compare(String s1, String s2) {
                return Ints.compare(s1.length(), s2.length());
            }
        }
        //创建一个集合(也是guava的api)
        List<String> toSort = Arrays.asList("zz", "aa", "b", "ccc");
        Ordering<String> byLength = new OrderingByLenght();
        Collections.sort(toSort, byLength);
        //自定义一个期望的排序结果的排序器
        Ordering<String> expectedOrder = Ordering.explicit(Lists.newArrayList("b", "zz", "aa", "ccc"));
        //判断上面的集合是否按照期望的排序结果排序
        Preconditions.checkState(expectedOrder.isOrdered(toSort));


        /**
         * reverse()
         */
        List<Integer> toSort = Arrays.asList(3, 5, 4, null, 1, 2);
        //反转Ordering.natural().nullsLast()
        Collections.sort(toSort, Ordering.natural().nullsLast().reverse());
        Preconditions.checkState(toSort.get(0) == null);


        /**
         * compound():组合排序器
         */
        List<String> toSort = Arrays.asList("zz", "aa", null, "b", "ccc");
        Collections.sort(toSort,
                new OrderingByLenght().reverse().compound(Ordering.natural()).nullsLast());
        System.out.println(toSort);


        /**
         * sortedCopy():创建一个按照排序器排序后的集合，但是不影响原集合的顺序
         */
        List<String> toSort = Arrays.asList("aa", "b", "ccc");
        List<String> sortedCopy = new OrderingByLenght().sortedCopy(toSort);
        Ordering<String> expectedOrder = Ordering.explicit(Lists.newArrayList("b", "aa", "ccc"));
        //验证原集合是否被排序
        Preconditions.checkState(expectedOrder.isOrdered(toSort));
        //验证新集合是否被排序
        Preconditions.checkState(expectedOrder.isOrdered(sortedCopy));

    }


    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        orderingTest();
    }
}

以上是Guava基础工具的简单使用。