Guava使用案例

Guava使用案例

介绍

Guava是一种基于开源的Java库,谷歌很多项目使用它的很多核心库。这个库是为了方便编码,并减少编码错误。本篇文章主要以测试实例来讲解Guava比较常用的一些类和功能

基础工具类

Guava提供的Preconditions类中有一些基础前置检查方法，当检查不通过时迅速抛出错误。

        int i = 1;
        String a = "";
        int j[] = {4, 1, 2, 3};
        List l = Ints.asList(j);

        //前置检查方法
        //条件检查 不通过抛出IllegalArgumentException及自定义描述 自定义描述支持类似于String.format()的字符串拼接但是只能用%s
        checkArgument(i >= 0, "Argument was %s but expected nonnegative", i);
        //空值检查 不通过抛出NullPointerException及自定义描述
        checkNotNull(a, "Argument was null");
        //状态检查 不通过抛出IllegalStateException及自定义描述
        checkState(i >= 0, "Argument was %s but expected nonnegative", i);
        //检查列表、字符串或数组某一索引是否有效 不通过抛出IndexOutOfBoundsException
        checkElementIndex(2, l.size());
        //检查列表、字符串或数组某一位置是否有效 不通过抛出IndexOutOfBoundsException
        checkPositionIndex(2, l.size());
        //检查列表、字符串或数组某一范围是否有效 不通过抛出IndexOutOfBoundsException
        checkPositionIndexes(1, 2, l.size());

Objects方法提供了比较null的方法

        //Objects支持null的对比方法
        Objects.equal("a", "a"); // returns true
        Objects.equal(null, "a"); // returns false
        Objects.equal("a", null); // returns false
        Objects.equal(null, null); // returns true

排序器及对比器

        //对可排序类型做自然排序，如数字按大小，日期按先后排序
        List sortl = Ordering.natural().sortedCopy(l);
        //按对象的字符串形式做字典排序
        Ordering.usingToString();
        //自定义排序器 - 比较字符串长度
        Ordering byLengthOrdering = new Ordering() {
            public int compare(String left, String right) {
                return Ints.compare(left.length(), right.length());
            }
        };

        //排序器能够支持链式调用
        Ordering.natural()
                //获取语义相反的排序器
                .reverse()
                //使用当前排序器，但额外把null值排到最前面
                .nullsFirst()
                //使用当前排序器，但额外把null值排到最后面
                .nullsLast()
                //合成另一个比较器，以处理当前排序器中的相等情况。
                .compound(new Comparator() {
                    @Override
                    public int compare(Integer i, Integer j) {
                        return 0;
                    }
                })
                //基于处理类型T的排序器，返回该类型的可迭代对象Iterable的排序器
                .lexicographical();
        //对集合中元素调用Function，再按返回值用当前排序器排序
        class Foo {
            @Nullable
            String sortedBy;

            int notSortedBy;
        }
        Ordering ordering = Ordering.natural().nullsFirst().onResultOf(new Function() {
            public String apply(Foo foo) {
                return foo.sortedBy;
            }
        });
        //以下是具体排序方法
        //获取可迭代对象中最大的k个元素。
        Ordering.natural().greatestOf(l, 3);
        //判断可迭代对象是否已按排序器排序：允许有排序值相等的元素。
        Ordering.natural().isOrdered(l);
        //进行排序 并把排序结果copy成另一个集合
        List sortedl = Ordering.natural().sortedCopy(l);
        //返回两个参数中最小的那个。如果相等，则返回第一个参数。
        Ordering.natural().min(1, 2);
        //返回多个参数中最小的那个。如果有超过一个参数都最小，则返回第一个最小的参数。
        Ordering.natural().min(1, 2, 3, 4);
        //返回迭代器中最小的元素。如果可迭代对象中没有元素，则抛出NoSuchElementException。
        Ordering.natural().min(l);
        //同理max
        Ordering.natural().max(1, 2);

集合工具类

不可变集合：静态集合不可修改

        //以set为例
        ImmutableSet foob = ImmutableSet.of("a", "b", "c");
        ImmutableSet GOOGLE_COLORS = ImmutableSet.builder().add(new Color(0, 190, 255)).build();
        ImmutableSet defensiveCopy = ImmutableSet.copyOf(l);
        //同理类似的类就是集合前面加上Immutable 包括Collection

Multiset接口与MultiMap的系列集合：提供一个可以统计元素插入重复次数的无序集合

        //Multiset
        Multiset countMap = HashMultiset.create();
        //插入字符串"aa"2次
        countMap.add("aa", 3);
        //删除n次
        countMap.remove("aa", 1);
        //获取不重复的元素只获取到一个aa
        countMap.elementSet();
        //统计aa插入的次数
        countMap.count("aa");
        //和Map的entrySet类似 返回set类型的entry集 支持getElement()和getCount()方法
        countMap.entrySet();
        //给定元素固定次数
        countMap.setCount("aa", 5);
        //返回集合元素的总个数(重复的也记录 若想去重使用countMap.elementSet().size())
        countMap.size();

        //Multimap系列接口集合 和Multiset很相似 可以理解成Multiset的map版本 对应的实现将上面的对应map改为Multimap
        //Multimap主要是为了一个键映射到多个值。换句话说，Multimap是把键映射到任意多个值的一般方式。
        //可以和传统的缓存Map>进行对比
        Multimap multimap = HashMultimap.create();
        //转换成Map>格式 且对转换后的map做操作会影响原有的Multimap
        multimap.asMap();
        //添加键到单个值的映射
        multimap.put(1, "a");
        //添加多个值的映射
        multimap.putAll(2, Lists.newArrayList("a", "b", "c", "d"));
        //移除键到值的映射；如果有这样的键值并成功移除，返回true。
        multimap.remove(2, "b");
        //移除一个key所有的映射值
        multimap.removeAll(1);
        //替换原有的映射值集合
        multimap.replaceValues(2, Lists.newArrayList("a", "b", "c", "d"));

BiMap系列接口集合：为了解决实现键值对的双向映射需要维护两个单独的map的问题

        //其对应的实现HashBiMap，ImmutableBiMap，EnumBiMap，EnumHashBiMap
        BiMap userId = HashBiMap.create();
        userId.put(1, "tom");
        //在想使用反向映射时使用inverse反转键值对关系
        userId.inverse().get("tom");

table ：行 列 值

        Table weightedGraph = HashBasedTable.create();
        weightedGraph.put(1, 2, 4);
        weightedGraph.put(1, 3, 20);
        weightedGraph.put(2, 3, 5);
        //返回某一行的列对应值的map
        weightedGraph.row(1); // returns a Map mapping 2 to 4, 3 to 20
        //返回某一列的行对应值的map
        weightedGraph.column(3); // returns a Map mapping 1 to 20, 2 to 5

ClassToInstanceMap系列接口：是一种特殊的Map：它的键是类型，而值是符合键所指类型的对象

        //Guava提供了两种有用的实现：MutableClassToInstanceMap和 ImmutableClassToInstanceMap。
        ClassToInstanceMap numberDefaults = MutableClassToInstanceMap.create();
        numberDefaults.putInstance(Integer.class, Integer.valueOf(0));

RangeSet与RangeMap类：用来表述区间

        //当把一个区间添加到可变的RangeSet时，所有相连的区间会被合并，空区间会被忽略。
        RangeSet rangeSet = TreeRangeSet.create();
        rangeSet.add(Range.closed(1, 10)); // {[1,10]}
        rangeSet.add(Range.closedOpen(11, 15));//不相连区间:{[1,10], [11,15)}
        rangeSet.add(Range.closedOpen(15, 20)); //相连区间; {[1,10], [11,20)}
        rangeSet.add(Range.openClosed(0, 0)); //空区间; {[1,10], [11,20)}
        rangeSet.remove(Range.open(5, 10)); //分割[1, 10]; {[1,5], [10,10], [11,20)}

        //RangeMap类除了上述区间形容外 描述了”不相交的、非空的区间”到特定值的映射
        //和RangeSet不同，RangeMap不会合并相邻的映射，即便相邻的区间映射到相同的值。
        //Range区间也是Guava提供的一种新类型
        RangeMap rangeMap = TreeRangeMap.create();
        rangeMap.put(Range.closed(1, 10), "foo"); //{[1,10] => "foo"}
        rangeMap.put(Range.open(3, 6), "bar"); //{[1,3] => "foo", (3,6) => "bar", [6,10] => "foo"}
        rangeMap.put(Range.open(10, 20), "foo"); //{[1,3] => "foo", (3,6) => "bar", [6,10] => "foo", (10,20) => "foo"}
        rangeMap.remove(Range.closed(5, 11)); //{[1,3] => "foo", (3,5) => "bar", (11,20) => "foo"}

集合类工具：对应集合类后面加上s

        //Lists
        List intList = Ints.asList(4, 5, 6);
        List theseElements = Lists.newArrayList("alpha", "beta", "gamma");
        //反转List
        List thoseElements = Lists.reverse(theseElements);
        //指定大小分割
        List> conList = Lists.partition(thoseElements, 3);
        //Sets
        Set wordsWithPrimeLength = ImmutableSet.of("one", "two", "three", "six", "seven", "eight");
        Set primes = ImmutableSet.of("two", "three", "five", "seven");
        //联合两个set
        Sets.union(wordsWithPrimeLength, primes);
        //求交集
        Sets.intersection(wordsWithPrimeLength, primes);

        //Maps
        Map left = ImmutableMap.of("a", 1, "b", 2, "c", 3);
        Map right = ImmutableMap.of("b", 2, "c", 4, "d", 4);
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点。该方法返回MapDifference对象，把不同点的维恩图分解
        MapDifference diff = Maps.difference(left, right);
        //找到键值对都相等的
        diff.entriesInCommon(); // {"b" => 2}
        //找到键相等值不想等的
        diff.entriesDiffering(); // {"c" => 3},{"c" => 4}
        //找到只存在于左边的
        diff.entriesOnlyOnLeft(); // {"a" => 1}
        //找到只存在于右边的
        diff.entriesOnlyOnRight(); // {"d" => 5}

        //Iterables工具类连接两个Iterable（集合）
        Iterable concatenated = Iterables.concat(
                Ints.asList(1, 2, 3),
                Ints.asList(4, 5, 6)); // concatenated包括元素 1, 2, 3, 4, 5, 6

        //Tables
        Table table = HashBasedTable.create();
        //把Table转置成Table 也就是行列互换
        Tables.transpose(table);

缓存

Guava提供了一套缓存类，如果希望系统牺牲内存空间去执行的更快速，可以使用它

        //cache缓存
        // LoadingCache是Cache的缓存实现
        LoadingCache cache = CacheBuilder.newBuilder()
                //设置缓存大小
                .maximumSize(1000)
                //设置到期时间
                .expireAfterWrite(10, TimeUnit.MINUTES)
                //设置缓存里的值两分钟刷新一次
                .refreshAfterWrite(2,TimeUnit.MINUTES)
                //开启缓存的统计功能
                .recordStats()
                //构建缓存
                .build(new CacheLoader() {
                    //此处实现如果根据key找不到value需要去如何获取
                    @Override
                    public Object load(String s) throws Exception {
                        return new Foo();
                    }

                    //如果批量加载有比反复调用load更优的方法则重写这个方法
                    @Override
                    public Map loadAll(Iterable keys) throws Exception {
                        return super.loadAll(keys);
                    }
                });
        cache.put("aa", new Foo());
        cache.get("aa");
        //除了在build的时候设置没有key的调用方法外我们还能在调用的时候手动写
        String key = "bb";
        cache.get(key, new Callable