guava的新集合类型

Multiset占据了List和Set之间的一个灰色地带：允许重复，但是不保证顺序。
常见使用场景：Multiset有一个有用的功能，就是跟踪每种对象的数量，所以你可以用来进行数字统计

 @Test
    public void testMultiSet(){
        HashMultiset<String> multiSet = HashMultiset.create();
        multiSet.addAll(ImmutableList.of("Paul","Dean"));
        multiSet.add("Paul",3);
        multiSet.add("Paul");
        System.out.println(multiSet);
        System.out.println(multiSet.size());
        System.out.println(multiSet.count("Paul"));
    }

结果:
[Paul x 5, Dean]
6
5

Multimap可以很方便的实现Map<String,List<StudentDto>> 这种结构

@Test
    public void testMultiMap(){
        Multimap<String, User> map = ArrayListMultimap.create();
        User user1 = new User("Paul",22);
        User user2 = new User("Dean",33);
        User user3 = new User("Lily",33);
        map.put("Super",user1);
        map.put("Super",user2);
        map.put("Non",user3);
        for (Map.Entry<String,User> entry : map.entries()) {
            System.out.println("key:"+entry.getKey()+"  Value:"+entry.getValue());
        }
        System.out.println(map.get("Super"));

        System.out.println("all keys: "+map.keys());
    }

BiMap提供了一种新的集合类型，它提供了key和value的双向关联的数据结构。

 @Test
    public void testBiMap(){
        BiMap<String,Integer> map = ImmutableBiMap.of("Paul",22,"Dean",16);
        //inverse方法会返回一个反转的BiMap，但是注意这个反转的map不是新的map对象，它实现了一种视图关联，这样你对于反转后的map的所有操作都会影响原先的map对象
        LOGGER.info("通过BiMap反向获取key值：{}",map.inverse().get(22));
    }

对map的值进行操作

@Test
    public void mapTransformationValue(){
        ImmutableMap<String,Integer> map = ImmutableMap.of("a",1,"b",2,"c",3);
        Map<String,Integer> newMap = Maps.transformValues(map, v -> v+1);
        for (String key : newMap.keySet()) {
            System.out.println("key:"+key+"  Value:" + newMap.get(key));
        }
    }

对List的值进行操作

 @Test
    public void listTransformationTest(){
        List<String> strList = Lists.newArrayList("asd","wer","Jons","jean","Peter");
        List<String>  newList1 = Lists.transform(strList,s -> s.toUpperCase());
        newList1.forEach(System.out::println);

        strList.stream().map(String::toLowerCase).forEach(System.out::println);
    }

//com.google.common.primitices包下的Ints，Doubles，Floats，Shorts，Bytes以及Bools
    @Test
    public void compare(){
        //返回-1，0，1
        int x = Ints.compare(1,2);
        LOGGER.info("max : {}",x);
        //包含关系
        boolean y = Doubles.contains(new double[]{1,2,3},1);
        LOGGER.info("Contains : {}",y);
        String array = Ints.join(",",1,2,3);
        LOGGER.info("join : {}" , array);
        float max = Floats.max(1,2,3,4);
        LOGGER.info("Max : {}",max);

    }

结果：
max : -1
Contains : true
join : 1,2,3
Max : 4.0

/**
     * Guava 中的String
     */
    @Test
    public void stringCommon(){
        //判断字符串为null和空
        String input = "";
        boolean isNullOrEmpty = Strings.isNullOrEmpty(input);
        System.out.println("input " + (isNullOrEmpty?"is":"is not") + " null or empty.");

        //获取字符串相同的前缀
        String a = "com.jd.coo.Hello";
        String b = "com.jd.coo.Hi";
        String ourCommonPrefix = Strings.commonPrefix(a,b);
        System.out.println("a,b common prefix is " + ourCommonPrefix);

        //获取字符串相同的后缀
        String c = "com.google.Hello";
        String d = "com.jd.Hello";
        String ourSuffix = Strings.commonSuffix(c,d);
        System.out.println("c,d common suffix is " + ourSuffix);

        //补全字符串
        int minLength = 4;
        String padEndResult = Strings.padEnd("123", minLength, '0');
        System.out.println("****************补全字符串***************");
        System.out.println("padEndResult is " + padEndResult);
        String padStartResult = Strings.padStart("1", 2, '0');
        System.out.println("padStartResult is " + padStartResult);
    }

input is null or empty.
a,b common prefix is com.jd.coo.H
c,d common suffix is .Hello
****************补全字符串***************
padEndResult is 1230
padStartResult is 01

当出现null值时，Joiner可以很好的处理

@Test
    public void testGuavaJoiner(){
        String[] x = {"as","sad","rt4"};
        LOGGER.info("Result of Joiner : {}", Joiner.on("==").join(x));

        List<String> list = Arrays.asList("123","asd",null,"fghh");
        LOGGER.info("Result of Joiner except null: {}",Joiner.on(",").skipNulls().join(list));

        ImmutableMap<String,Integer> map = ImmutableMap.of("1",11,"2",22,"3",33);
        LOGGER.info("Result of Joiner map: {}" , Joiner.on(",").withKeyValueSeparator("=").join(map));
    }

结果：
as==sad==rt4
123,asd,fghh
1=11,2=22,3=33

很好的字符串分割

 /**
     * Guava中的Splitter
     * on():指定分隔符来分割字符串
     * limit():当分割的子字符串达到了limit个时则停止分割
     * fixedLength():根据长度来拆分字符串
     * trimResults():去掉子串中的空格
     * omitEmptyStrings():去掉空的子串
     * withKeyValueSeparator():要分割的字符串中key和value间的分隔符,分割后的子串中key和value间的分隔符默认是=
     *
     */

    @Test
    public void splitterCommon(){
        ImmutableMap<String,Integer> map = ImmutableMap.of("1",11,"2",22,"3",33);
        String mapString = Joiner.on(",").withKeyValueSeparator("=").join(map);
        Map<String,String> map1 = Splitter.on(",").withKeyValueSeparator("=").split(mapString);
        LOGGER.info("Result of Joiner map: {}" , map1);

    }



    //Splitter类返回的是Iterator类型的接口
    @Test
    public void splitterLimit(){
        String str = "1#2#3#4#5#6#7";
        LOGGER.info("Result of split by limit:{}",Splitter.on("#").limit(3).split(str));

        String strWithSpace = "1#2##3##4###5#6";
        LOGGER.info("Result of split by limit and space(doesn't deal with space):{}",Splitter.on("#").split(strWithSpace));

        LOGGER.info("Result of split by limit and space:{}",Splitter.on("#").omitEmptyStrings().split(strWithSpace));

        Iterable iterable = Splitter.on("#").limit(3).split(str);
        Iterator iterator = iterable.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

对集合的一些排序、最大、最小值的处理

/**
     * Guava的比较器Ordering
     *    reverse(): 返回与当前Ordering相反的排序:
     * 　　nullsFirst(): 返回一个将null放在non-null元素之前的Ordering，其他的和原始的Ordering一样；
     * 　　nullsLast()：返回一个将null放在non-null元素之后的Ordering，其他的和原始的Ordering一样；
     * 　　compound(Comparator)：返回一个使用Comparator的Ordering，Comparator作为第二排序元素，例如对bug列表进行排序，先根据bug的级别，再根据优先级进行排序；
     * 　　lexicographical()：返回一个按照字典元素迭代的Ordering；
     * 　　onResultOf(Function)：将function应用在各个元素上之后, 在使用原始ordering进行排序；
     * 　　greatestOf(Iterable iterable, int k)：返回指定的第k个可迭代的最大的元素，按照这个从最大到最小的顺序。是不稳定的。
     * 　　leastOf(Iterable<E> iterable,int k)：返回指定的第k个可迭代的最小的元素，按照这个从最小到最大的顺序。是不稳定的。
     * 　　isOrdered(Iterable)：是否有序，Iterable不能少于2个元素。
     * 　　isStrictlyOrdered(Iterable)：是否严格有序。请注意，Iterable不能少于两个元素。
     * 　　sortedCopy(Iterable)：返回指定的元素作为一个列表的排序副本。
     */
    @Test
    public void testOrdering(){
        List<String> strList = Lists.newArrayList("asd","wer","Jons","jean","Peter");
        List<String> strList2 = Lists.newArrayList("asd","wer","Jons",null,"jean","Peter");
        List<String> naturalSortedList = Ordering.natural().sortedCopy(strList);
        List<String> naturalRecersedList = Ordering.natural().reverse().sortedCopy(strList);
        List<String> nullFirstList = Ordering.natural().nullsFirst().sortedCopy(strList2);
        List<String> nullLastList = Ordering.natural().nullsLast().sortedCopy(strList2);
        System.out.println("naturalSortedList:"+naturalSortedList+"\nnaturalRecersedList:"+naturalRecersedList+"\nnullFirstList:"+
                nullFirstList+"\nnullLastList:"+nullLastList);

        List<Integer> intList = Arrays.asList(1,2,346,67,8,45,232,69);
        int min = Ordering.natural().min(intList);
        int max = Ordering.natural().max(intList);
        System.out.println("Min:"+min+"Max: "+max);

        ImmutableList<User> users = ImmutableList.of(new User("Dean",22),
                new User("Xiao",33),
                new User("Paul",25));

        List<String> userNames = Lists.transform(users, new Function<User, String>() {
            @Nullable
            @Override
            public String apply(@Nullable User user) {
                return user.getAge() > 24 ? user.getName() : "";
            }
        });

        Collection<String> collection = Collections2.filter(userNames,Predicates.isNull());
        System.out.println("transformList:"+collection);

    }