Guava中针对集合的 filter和过滤功能 

                                            Guava中针对集合的 filter和过滤功能                    </a>
            </span>
        </h1>
    </div>
    <div class="article_manage clearfix">
    <div class="article_r">
    <span class="link_postdate">2016年07月30日 17:28:04</span>
    <span class="link_view" title="阅读次数">1001人阅读</span>
    <span class="link_comments" title="评论次数"> <a href="javascript:void(0);" class="btn-pinglun">评论</a>(0)</span>
    <span class="link_collect csdn-tracking-statistics" data-pid="blog" data-mod="popu_171">
        <a href="javascript:void(0);" onclick="javascript:collectArticle('Guava中针对集合的 filter和过滤功能','52073877');return false;" title="收藏" target="_blank">收藏</a>
    </span>
            <span class="link_report">
        <a href="javascript:void(0);" onclick="javascript:report(52073877, 2);return false;" title="举报">举报</a>
    </span>
                </div>

分类：
作者同类文章 X

    在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子： 

    [java] view plain copy
     print?
    1. @Test  
    2. public void whenFilterWithIterables_thenFiltered() {  
    3.     List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");  
    4.     Iterable<String> result = Iterables.filter(names, Predicates.containsPattern("a"));  
    5.    
    6.     assertThat(result, containsInAnyOrder("Jane", "Adam"));  
    7. }  


    在这个例子中，给出一个list，过滤出含有字母a的元素 

    此外，可以使用Collections2.filter() 去进行过滤 

    [java] view plain copy
     print?
    1. @Test  
    2. public void whenFilterWithCollections2_thenFiltered() {  
    3.     List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");  
    4.     Collection<String> result = Collections2.filter(names, Predicates.containsPattern("a"));  
    5.        
    6.     assertEquals(2, result.size());  
    7.     assertThat(result, containsInAnyOrder("Jane", "Adam"));  
    8.    
    9.     result.add("anna");  
    10.     assertEquals(5, names.size());  
    11. }  


    这里注意的是，Collections2.filter中，当在上面的result中增加了元素后，会直接影响原来的names这个list的，就是names中的集合元素是5了。 

      再来看下predicates判断语言， 

    com.google.common.base. Predicate : 根据输入值得到 true 或者 false 

    拿Collections2中有2个函数式编程的接口：filter , transform ,例如 ：在Collection<Integer>中过滤大于某数的内容： 

    [java] view plain copy
     print?
    1. Collection<Integer> filterList = Collections2.filter(collections  
    2.   
    3.      , new Predicate<Integer>(){  
    4.   
    5.                   @Override  
    6.   
    7.                   public boolean apply(Integer input) {  
    8.   
    9.                         if(input > 4)  
    10.   
    11.                               return false;  
    12.   
    13.                         else  
    14.   
    15.                               return true;  
    16.   
    17.                   }  
    18.   
    19. });  


    把Lis<Integer>中的Integer类型转换为String , 并添加test作为后缀字符： 

    [java] view plain copy
     print?
    1. List<String> c2 = Lists.transform(list, new Function<Integer , String>(){  
    2.   
    3.                   @Override  
    4.   
    5.                   public String apply(Integer input) {  
    6.   
    7.                         return String.valueOf(input) + "test";  
    8.   
    9.                   }              
    10.   
    11. });  


    需要说明的是每次调用返回都是新的对象，同时操作过程不是线程安全的。 

        再来点例子： 

    [java] view plain copy
     print?
    1. @Test  
    2. public void whenFilterCollectionWithCustomPredicate_thenFiltered() {  
    3.     Predicate<String> predicate = new Predicate<String>() {  
    4.         @Override  
    5.         public boolean apply(String input) {  
    6.             return input.startsWith("A") || input.startsWith("J");  
    7.         }  
    8.     };  
    9.    
    10.     List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");  
    11.     Collection<String> result = Collections2.filter(names, predicate);  
    12.    
    13.     assertEquals(3, result.size());  
    14.     assertThat(result, containsInAnyOrder("John", "Jane", "Adam"));  
    15. }  


    将多个prdicate进行组合 

    [java] view plain copy
     print?
    1. @Test  
    2. public void whenFilterUsingMultiplePredicates_thenFiltered() {  
    3.     List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");  
    4.     Collection<String> result = Collections2.filter(names,   
    5.       Predicates.or(Predicates.containsPattern("J"),   
    6.       Predicates.not(Predicates.containsPattern("a"))));  
    7.    
    8.     assertEquals(3, result.size());  
    9.     assertThat(result, containsInAnyOrder("John", "Jane", "Tom"));  
    10. }  


    上面的例子中找出包含J字母或不包含a的元素; 

       

    再看下如何将集合中的空元素删除： 

    [java] view plain copy
     print?
    1. @Test  
    2. public void whenRemoveNullFromCollection_thenRemoved() {  
    3.     List<String> names = Lists.newArrayList("John", null, "Jane", null, "Adam", "Tom");  
    4.     Collection<String> result = Collections2.filter(names, Predicates.notNull());  
    5.    
    6.     assertEquals(4, result.size());  
    7.     assertThat(result, containsInAnyOrder("John", "Jane", "Adam", "Tom"));  
    8. }  


    检查一个collection中的所有元素是否符合某个条件： 

    [java] view plain copy
     print?
    1. @Test  
    2. ublic void whenCheckingIfAllElementsMatchACondition_thenCorrect() {  
    3.    List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");  
    4.   
    5.    boolean result = Iterables.all(names, Predicates.containsPattern("n|m"));  
    6.    assertTrue(result);  
    7.   
    8.    result = Iterables.all(names, Predicates.containsPattern("a"));  
    9.    assertFalse(result);  


    下面看如何把一个list进行转换， 

    [java] view plain copy
     print?
    1. @Test  
    2. public void whenTransformWithIterables_thenTransformed() {  
    3.     Function<String, Integer> function = new Function<String, Integer>() {  
    4.         @Override  
    5.         public Integer apply(String input) {  
    6.             return input.length();  
    7.         }  
    8.     };  
    9.    
    10.     List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");  
    11.     Iterable<Integer> result = Iterables.transform(names, function);  
    12.    
    13.     assertThat(result, contains(4, 4, 4, 3));  
    14. }  


    在这个例子中，将一个LIST中的每一个元素进行使用Predicates.containsPattern，判断是否包含m，返回的是boolean，然后再得到的boolean值一起转换为collection 



        下面是两个function一起结合使用的例子： 

    [java] view plain copy
     print?
    1. @Test  
    2. public void whenTransformingUsingComposedFunction_thenTransformed() {  
    3.     Function<String,Integer> f1 = new Function<String,Integer>(){  
    4.         @Override  
    5.         public Integer apply(String input) {  
    6.             return input.length();  
    7.         }  
    8.     };  
    9.    
    10.     Function<Integer,Boolean> f2 = new Function<Integer,Boolean>(){  
    11.         @Override  
    12.         public Boolean apply(Integer input) {  
    13.             return input % 2 == 0;  
    14.         }  
    15.     };  
    16.    
    17.     List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");  
    18.     Collection<Boolean> result = Collections2.transform(names, Functions.compose(f2, f1));  
    19.    
    20.     assertEquals(4, result.size());  
    21.     assertThat(result, contains(true, true, true, false));  
    22. }  


    在这个例子中，首先应用函数f1，求出每个元素的长度，然后再根据f1函数，分别返回 

    它们的boolean值，再转换为collection. 

       

       最后看下将filter和transform结合使用的例子： 

    [java] view plain copy
     print?
    1. @Test  
    2. public void whenFilteringAndTransformingCollection_thenCorrect() {  
    3.     Predicate<String> predicate = new Predicate<String>() {  
    4.         @Override  
    5.         public boolean apply(String input) {  
    6.             return input.startsWith("A") || input.startsWith("T");  
    7.         }  
    8.     };  
    9.    
    10.     Function<String, Integer> func = new Function<String,Integer>(){  
    11.         @Override  
    12.         public Integer apply(String input) {  
    13.             return input.length();  
    14.         }  
    15.     };  
    16.    
    17.     List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");  
    18.     Collection<Integer> result = FluentIterable.from(names)  
    19.                                                .filter(predicate)  
    20.                                                .transform(func)  
    21.                                                .toList();  
    22.    
    23.     assertEquals(2, result.size());  
    24.     assertThat(result, containsInAnyOrder(4, 3));  
    25. }  


                                      <li class="next_article">
            <span onclick="_gaq.push(['_trackEvent','function', 'onclick', 'blog_articles_xiayipian']);location.href='http://blog.csdn.net/victor_cindy1/article/details/52074424';">下一篇</span>
            <a href="http://blog.csdn.net/victor_cindy1/article/details/52074424" onclick="_gaq.push(['_trackEvent','function', 'onclick', 'blog_articles_xiayipian'])">spring &lt;context:annotation-config&gt; 跟 &lt;context:component-scan&gt;诠释及区别</a>
        </li>
                </ul>
    <div style="clear:both; height:10px;"></div>
</div>
    posted @ 2018-03-17 14:01  jobs-lgy  阅读(255)  评论(0)  编辑  收藏  举报