zoukankan      html  css  js  c++  java
  • Guava API

    1、字符串的处理

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

      Joiner&Splitter

     1     @Test
     2     public void testJoiner() {
     3         String[] strs = new String[]{"pan",null,"teng"};
     4         //由于字符串中含有null  因此会抛出异常,需要调用以下方法
     5         //Joiner joiner = Joiner.on("-").skipNulls();    //跳过 null
     6         Joiner joiner = Joiner.on("-").useForNull("空");    //将null用“空” 替换
     7         //joiner.skipNulls();    这样调用是不行的,不会改变 joiner,需要将skipNulls 返回值赋给joiner才行
     8         String joinStr = joiner.join(strs[0], strs[1], strs[2]);
     9         System.out.println("joinStr = " + joinStr);
    10         //joiner 还可以连接对象,这种情况下 会调用对象的toString方法,将对象转换为String
    11     }
    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 /**
     2      * 1. 可以将MultiSet看成map, 作为计数器,key 为元素,值为计数器
     3      * 2. 
     4      */
     5     @Test
     6     public void testMultiSet(){
     7         Multiset<String> multisets = HashMultiset.create();
     8         String[] strArray = new String[]{"one","one","two","three"};
     9         
    10         //添加元素
    11         multisets.addAll(Arrays.asList(strArray));
    12         multisets.add("four");
    13         
    14         //添加指定个数的元素
    15         multisets.add("five", 3);
    16         //[two, five x 3, one x 2, three, four]
    17         System.out.println("打印multiset:" + multisets);
    18         //返回元素总个数
    19         System.out.println("元素总个数:" + multisets.size());
    20         
    21         //遍历
    22         Iterator<String> iterator = multisets.iterator();
    23         //two,five,five,five,one,one,three,four,
    24         while(iterator.hasNext()){
    25             System.out.print(iterator.next() + ",");
    26         }
    27         System.out.println();
    28         Set<Entry<String>> entitySet = multisets.entrySet();//?????
    29         System.out.println("???" + entitySet);
    30         
    31         //返回给定元素的个数
    32         System.out.println("返回指定元素的重复次数:" + multisets.count("one"));
    33         
    34         //移除某元素的一个
    35         multisets.remove("one");
    36         System.out.println("移除后:" + multisets.count("one"));
    37         //移除某元素的所有
    38         multisets.setCount("one",0);
    39         System.out.println("移除one所有后:" + multisets);
    40         
    41         //将不同元素放入一个Set
    42         Set<String> uniqueSet = multisets.elementSet();
    43         System.out.println("不同元素放入一个SET:" + uniqueSet);
    44         
    45         //设定一个元素的重复次数
    46         multisets.setCount("three", 3);
    47         System.out.println("打印multiset:" + multisets);
    48     
    49     }
    可重复集合

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

     1 @Test
     2     /**
     3      * ArrayListMultimap
     4         HashMultimap
     5         LinkedListMultimap*
     6         LinkedHashMultimap**
     7         TreeMultimap
     8         ImmutableListMultimap
     9         ImmutableSetMultimap
    10      */
    11     public void testMultiMap(){
    12         Multimap<String, String> mutimap = HashMultimap.create();
    13         mutimap.put("father_a", "son_a1");
    14         mutimap.put("father_a", "son_a2");
    15         mutimap.put("father_a", "son_a3");
    16         
    17         mutimap.put("father_b", "son_b1");
    18         mutimap.put("father_b", "son_b2");
    19         mutimap.put("father_b", "son_b3");
    20         
    21         //{father_a=[son_a1, son_a3, son_a2], father_b=[son_b3, son_b2, son_b1]}
    22         System.out.println("mutimap = " + mutimap);
    23         
    24         //整体添加
    25         ArrayList<String> father_c = new ArrayList<String>();
    26         father_c.add("son_C1");
    27         father_c.add("son_C2");
    28         mutimap.putAll("father_c", father_c);
    29         
    30         //获取某个key对应的元素
    31         Collection<String> father_a = mutimap.get("father_c");
    32         Iterator<String> iterator = father_a.iterator();
    33         while (iterator.hasNext()) {
    34             System.out.print(iterator.next() + ",");
    35         }
    36         System.out.println();
    37         
    38         //获取键值
    39         System.out.println("获取所有的键值:" + mutimap.keySet());
    40         
    41         //
    42     }
    一对多

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

     1 /**
     2      * 实际上是调用反转方法 获取到一个新的Map
     3      */
     4     @Test
     5     public void testBiMap(){
     6         Map<String, String> genMap = new HashMap<String, String>();
     7         genMap.put("one", "1");
     8         genMap.put("two", "2");
     9         genMap.put("three", "3");
    10         BiMap<String, String> twoDirectMap = HashBiMap.create();
    11         twoDirectMap.putAll(genMap);
    12         System.out.println("one = " + twoDirectMap.get("one"));
    13         System.out.println("1 = " + twoDirectMap.get("1"));
    14         
    15         //获取反转Map
    16         BiMap<String, String> twoDirectMap_mirror = twoDirectMap.inverse();
    17         System.out.println("one = " + twoDirectMap_mirror.get("one"));
    18         System.out.println("1 = " + twoDirectMap_mirror.get("1"));
    19         
    20     }
    双向Map
  • 相关阅读:
    利用NPOI导出数据到Execl
    分享微信开发Html5轻游戏中的几个坑
    Integrate non-OSGi Dependencies
    Websocket Component
    ServiceMix in daemon mode
    springboot jwt配置(更新中)
    npm run build 后的dist文件,发布到web服务。
    不重复随机数列的生成算法 Leetcode 384. Shuffle an Array
    LSM树-HBASE为什么快
    混沌工程初探
  • 原文地址:https://www.cnblogs.com/tengpan-cn/p/5752068.html
Copyright © 2011-2022 走看看