Guava API

1、字符串的处理

　　字符串的连接&拆分&匹配及常用操作

　　Joiner&Splitter

     @Test
     public void testJoiner() {
         String[] strs = new String[]{"pan",null,"teng"};
         //由于字符串中含有null  因此会抛出异常,需要调用以下方法
         //Joiner joiner = Joiner.on("-").skipNulls();    //跳过 null
         Joiner joiner = Joiner.on("-").useForNull("空");    //将null用“空” 替换
         //joiner.skipNulls();    这样调用是不行的，不会改变 joiner，需要将skipNulls 返回值赋给joiner才行
         String joinStr = joiner.join(strs[0], strs[1], strs[2]);
         System.out.println("joinStr = " + joinStr);
         //joiner 还可以连接对象，这种情况下 会调用对象的toString方法，将对象转换为String
     }

Joiner

/* CharMatcher 默认常量实现类:
         * ANY: 匹配任何字符
         * ASCII: 匹配是否是ASCII字符
         * BREAKING_WHITESPACE: 匹配所有可换行的空白字符(不包括非换行空白字符,例如"\u00a0")
         * DIGIT: 匹配ASCII数字
         * INVISIBLE: 匹配所有看不见的字符
         * JAVA_DIGIT: 匹配UNICODE数字, 使用 Character.isDigit() 实现
         * JAVA_ISO_CONTROL: 匹配ISO控制字符, 使用 Charater.isISOControl() 实现
         * JAVA_LETTER: 匹配字母, 使用 Charater.isLetter() 实现
         * JAVA_LETTER_OR_DIGET: 匹配数字或字母
         * JAVA_LOWER_CASE: 匹配小写
         * JAVA_UPPER_CASE: 匹配大写
         * NONE: 不匹配所有字符
         * SINGLE_WIDTH: 匹配单字宽字符, 如中文字就是双字宽
         * WHITESPACE: 匹配所有空白字符
         *
         * 常用操作方法:
         * 修剪[trim]、折叠[collapse]、移除[remove]、保留[retain]
         * CharMatcher is(char match): 返回匹配指定字符的Matcher
         * CharMatcher isNot(char match): 返回不匹配指定字符的Matcher
         * CharMatcher anyOf(CharSequence sequence): 返回匹配sequence中任意字符的Matcher
         * CharMatcher noneOf(CharSequence sequence): 返回不匹配sequence中任何一个字符的Matcher
         * CharMatcher inRange(char startInclusive, char endIncludesive): 返回匹配范围内任意字符的Matcher
         * CharMatcher forPredicate(Predicate<? super Charater> predicate): 返回使用predicate的apply()判断匹配的Matcher
         * CharMatcher negate(): 返回以当前Matcher判断规则相反的Matcher
         * CharMatcher and(CharMatcher other): 返回与other匹配条件组合做与来判断的Matcher
         * CharMatcher or(CharMatcher other): 返回与other匹配条件组合做或来判断的Matcher
         * boolean matchesAnyOf(CharSequence sequence): 只要sequence中有任意字符能匹配Matcher,返回true
         * boolean matchesAllOf(CharSequence sequence): sequence中所有字符都能匹配Matcher,返回true
         * boolean matchesNoneOf(CharSequence sequence): sequence中所有字符都不能匹配Matcher,返回true
         * int indexIn(CharSequence sequence): 返回sequence中匹配到的第一个字符的坐标
         * int indexIn(CharSequence sequence, int start): 返回从start开始,在sequence中匹配到的第一个字符的坐标
         * int lastIndexIn(CharSequence sequence): 返回sequence中最后一次匹配到的字符的坐标
         * int countIn(CharSequence sequence): 返回sequence中匹配到的字符计数
         * String removeFrom(CharSequence sequence): 删除sequence中匹配到到的字符并返回
         * String retainFrom(CharSequence sequence): 保留sequence中匹配到的字符并返回
         * String replaceFrom(CharSequence sequence, char replacement): 替换sequence中匹配到的字符并返回
         * String trimFrom(CharSequence sequence): 删除首尾匹配到的字符并返回
         * String trimLeadingFrom(CharSequence sequence): 删除首部匹配到的字符
         * String trimTrailingFrom(CharSequence sequence): 删除尾部匹配到的字符
         * String collapseFrom(CharSequence sequence, char replacement): 将匹配到的组(连续匹配的字符)替换成replacement
         * String trimAndCollapseFrom(CharSequence sequence, char replacement): 先trim在replace
         * */

匹配器及常用方法

@Test
    public void testSplitter(){
        String str = ",b,c,d,,f,";
        //JDK会自动丢掉最后一个分隔符 且 中间的无论是什么，都作为一个元素 放到数组中
        String[] strs = str.split(",");
        for(String s:strs){
            System.out.println("JDK-split:" + s + "-");
        }
        System.out.println("----------------------------");
        //Guava 提供了更多的可供选择的模式
        Iterable<String> iterable = Splitter.on(",")
                .trimResults()        //去除元素中的前导空格和后导空格
                .omitEmptyStrings()    //省略空字符串
                .limit(3)            //限制拆分元素的数量 前 n-1个正常拆分，最后的全部的作为1个元素,共拆出n个元素
                .split(str);
        Iterator<String> iterator = iterable.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + "-" );
            System.out.println();
        }
        //正则表达式匹配拆分
        System.out.println("--------------正则表达式--------------");
        String patternStr = "abc12def34ffg78jip";
        Iterable<String> iterable2 = Splitter.onPattern("[0-9]").split(patternStr);
        Iterator<String> iterator2 = iterable2.iterator();
        while (iterator2.hasNext()) {
            System.out.print(iterator2.next() + "&" );
        }
        System.out.println();
        System.out.println("----------------------------");
        //拆分器返回List
        ArrayList<String> list = Lists.newArrayList(
                iterable);
        System.out.println(list.get(0) + "-" + list.get(1));
        //数字匹配器
        String matchStr = "ab12c*(3de45你好jio：潘腾jA@#B6%7fC^&";
        System.out.println("保留数字：" + CharMatcher.DIGIT.retainFrom(matchStr));//保留所有数字
        System.out.println("去除数字：" + CharMatcher.DIGIT.removeFrom(matchStr));
        System.out.println("数字替换：" + CharMatcher.DIGIT.replaceFrom(matchStr,"*"));
        //大写字母匹配器
        System.out.println("获取所有大写字母：" + CharMatcher.JAVA_UPPER_CASE.retainFrom(matchStr));
        //单字节匹配器（汉字是双字节）
        System.out.println("去除单字节，获取双字节：" + CharMatcher.SINGLE_WIDTH.removeFrom(matchStr));

拆分 + 匹配器示例程序

2、集合

　　不可变集合：优点-线程安全，不需要考虑变化，节省空间和时间，效率高

　　注意：不可变集合不允许有null对象

/**
     * 测试不可变集合
     * @method: testImmutableSet() -by fjt
     * @TODO:   void
     */
    @Test
    public void testImmutableSet(){
        List<String> list = new ArrayList<String>(Arrays.asList("black","white","red","blue"));
        Map<String, String> map = new TreeMap<>();
        map.put("id", "20111907");
        map.put("name", "panteng");
        //创建的三种方式copyOf  of  Builder方法
        //ImmutableList<String> finalList = ImmutableList.copyOf(list);
        ImmutableList<String> finalList = ImmutableList.of("black","white","red","blue");//括号内写 list变量 会报错
        try{
            //finalList.add("yellow");    //抛出空指针异常
            //finalList.remove(0);        //抛出空指针异常
        }catch(Exception ex){
            System.out.println("List 异常信息：" + ex.getMessage());
        }

        ImmutableMap<String, String> finalMap = ImmutableMap.copyOf(map);
        try{
            System.out.println(finalMap.get("name"));
            finalMap.put("aa", "abcd");    //报异常
        }catch(Exception ex){
            System.out.println("Map 异常信息：" + ex.getMessage());
        }
        /** 不可变集合类型
         * ImmutableCollection
         * ImmutableList
         * ImmutableSet
         * ImmutableSortedSet
         * ImmutableMap
         * ImmutableSortedMap
         * ImmutableMultiset
         * ImmutableSortedMultiset
         * ImmutableMultimap
         * ImmutableListMultimap
         * ImmutableSetMultimap
         * ImmutableBiMap
         * ImmutableClassToInstanceMap
         * ImmutableTable
         */
    }

不可变集合

　　可重复元素的集合，可以将元素看为key，value为出现次数，用于统计。

 /**
      * 1. 可以将MultiSet看成map, 作为计数器，key 为元素，值为计数器
      * 2.
      */
     @Test
     public void testMultiSet(){
         Multiset<String> multisets = HashMultiset.create();
         String[] strArray = new String[]{"one","one","two","three"};

         //添加元素
         multisets.addAll(Arrays.asList(strArray));
         multisets.add("four");

         //添加指定个数的元素
         multisets.add("five", 3);
         //[two, five x 3, one x 2, three, four]
         System.out.println("打印multiset：" + multisets);
         //返回元素总个数
         System.out.println("元素总个数：" + multisets.size());

         //遍历
         Iterator<String> iterator = multisets.iterator();
         //two,five,five,five,one,one,three,four,
         while(iterator.hasNext()){
             System.out.print(iterator.next() + ",");
         }
         System.out.println();
         Set<Entry<String>> entitySet = multisets.entrySet();//?????
         System.out.println("???" + entitySet);

         //返回给定元素的个数
         System.out.println("返回指定元素的重复次数：" + multisets.count("one"));

         //移除某元素的一个
         multisets.remove("one");
         System.out.println("移除后：" + multisets.count("one"));
         //移除某元素的所有
         multisets.setCount("one",0);
         System.out.println("移除one所有后：" + multisets);

         //将不同元素放入一个Set
         Set<String> uniqueSet = multisets.elementSet();
         System.out.println("不同元素放入一个SET：" + uniqueSet);

         //设定一个元素的重复次数
         multisets.setCount("three", 3);
         System.out.println("打印multiset：" + multisets);

     }

可重复集合

　　MultiMap - 一个key可以对应多个值，可以认为是一个key对应一个集合，解决一对多的问题

 @Test
     /**
      * ArrayListMultimap
         HashMultimap
         LinkedListMultimap*
         LinkedHashMultimap**
         TreeMultimap
         ImmutableListMultimap
         ImmutableSetMultimap
      */
     public void testMultiMap(){
         Multimap<String, String> mutimap = HashMultimap.create();
         mutimap.put("father_a", "son_a1");
         mutimap.put("father_a", "son_a2");
         mutimap.put("father_a", "son_a3");

         mutimap.put("father_b", "son_b1");
         mutimap.put("father_b", "son_b2");
         mutimap.put("father_b", "son_b3");

         //{father_a=[son_a1, son_a3, son_a2], father_b=[son_b3, son_b2, son_b1]}
         System.out.println("mutimap = " + mutimap);

         //整体添加
         ArrayList<String> father_c = new ArrayList<String>();
         father_c.add("son_C1");
         father_c.add("son_C2");
         mutimap.putAll("father_c", father_c);

         //获取某个key对应的元素
         Collection<String> father_a = mutimap.get("father_c");
         Iterator<String> iterator = father_a.iterator();
         while (iterator.hasNext()) {
             System.out.print(iterator.next() + ",");
         }
         System.out.println();

         //获取键值
         System.out.println("获取所有的键值：" + mutimap.keySet());

         //
     }

一对多

　　双向Map,即可以通过key获取value  也可以很容易的通过value获取key  实现一对一的关系；需要注意的是，必须保证值是唯一的

 /**
      * 实际上是调用反转方法 获取到一个新的Map
      */
     @Test
     public void testBiMap(){
         Map<String, String> genMap = new HashMap<String, String>();
         genMap.put("one", "1");
         genMap.put("two", "2");
         genMap.put("three", "3");
         BiMap<String, String> twoDirectMap = HashBiMap.create();
         twoDirectMap.putAll(genMap);
         System.out.println("one = " + twoDirectMap.get("one"));
         System.out.println("1 = " + twoDirectMap.get("1"));

         //获取反转Map
         BiMap<String, String> twoDirectMap_mirror = twoDirectMap.inverse();
         System.out.println("one = " + twoDirectMap_mirror.get("one"));
         System.out.println("1 = " + twoDirectMap_mirror.get("1"));

     }

双向Map