Guava中Predicate的常见用法

最新推荐文章于 2021-02-28 01:56:54 发布

weixin_30693183

最新推荐文章于 2021-02-28 01:56:54 发布

阅读量148

点赞数

原文链接：http://www.cnblogs.com/onlychang92/p/5203139.html

版权

1. Predicate基本用法

guava提供了许多利用Functions和Predicates来操作Collections的工具，一般在 Iterables, Lists, Sets, Maps, Multimaps中用到。

Predicate最基本的用法就是对Collection进行过滤，guava中很多集合的filter方法都是用Predicate来实现过滤的。

Collection type	Filter method
`Iterable`	`Iterables.filter(Iterable, Predicate)`	`FluentIterable.filter(Predicate)`
`Iterator`	`Iterators.filter(Iterator, Predicate)`
`Collection`	`Collections2.filter(Collection, Predicate)`
`Set`	`Sets.filter(Set, Predicate)`
`SortedSet`	`Sets.filter(SortedSet, Predicate)`
`Map`	`Maps.filterKeys(Map, Predicate)`	`Maps.filterValues(Map, Predicate)`	`Maps.filterEntries(Map, Predicate)`
`SortedMap`	`Maps.filterKeys(SortedMap, Predicate)`	`Maps.filterValues(SortedMap, Predicate)`	`Maps.filterEntries(SortedMap, Predicate)`
`Multimap`	`Multimaps.filterKeys(Multimap, Predicate)`	`Multimaps.filterValues(Multimap, Predicate)`	`Multimaps.filterEntries(Multimap, Predicate)`

注意：

Lists没有提供filter方法；

过滤后的集合一般通过Lists.newArrayList(Collections2.filter(list, predicate))拿到。

2. Predicate接口

Predicate接口提供了一个泛型方法apply,在使用时根据需求实现

Predicate继承了Object的equals方法，并提供了多个实现，主要是为了提供一个通用的方法，用于Object为Predicate类型时。

package com.google.common.base;

import com.google.common.annotations.GwtCompatible;

import javax.annotation.Nullable;

@GwtCompatible
public interface Predicate<T> {
 
  boolean apply(@Nullable T input);

  @Override
  boolean equals(@Nullable Object object);
}

3. Predicates的常用方法

Predicates时guava中与Predicate配套使用的工具类，返回Predicate实例。

下面是一个例子

package link.mengya;

/**
 * Created by chang on 16/2/19.
 */
public class User {
    private String userName;
    private int age;

    public User(String userName, int age) {
        this.userName = userName;
        this.age = age;
    }

    public String getUserName() {
        return userName;
    }

    public int getAge() {
        return age;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package link.mengya.utils;

import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.Iterables;
import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;
import link.mengya.User;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * Created by chang on 16/2/19.
 */

/**
 * Predicate  返回为true 的保留， 返回为false的过滤掉
 * Predicates.and(predicate1, predicate2)  predicate1 与 predicate2 返回都为true的保留
 * Predicates.or(predicate1, predicate2)   predicate1 与 predicate2 有一个返回true 则保留
 */
public class PredicateTest {
    public static void main(String[] args){
        List<User> users = new ArrayList<User>();
        users.add(new User("chang",24));
        users.add(new User("chen",26));
        users.add(new User("sun",24));

        //保留age不为26的User
        Predicate<User> predicate1 = new Predicate<User>() {
            public boolean apply(User user) {
                if(user.getAge() != 26){
                    return true;
                }
                return false;
            }
        };


        //保留userName 是 chang 的user
        Predicate<User> predicate2 = new Predicate<User>() {
            public boolean apply(User user) {
                return Objects.equals(user.getUserName(),"chang");
            }
        };

        //保留age不为 26 以及 userName 是 chang 的User
        Predicate<User> predicate1_and_predicate2 = Predicates.and(predicate1, predicate2);

        //保留age不为26 或 userName 是 chang的User
        Predicate<User> predicate1_or_predicate2 = Predicates.or(predicate1, predicate2);

        //与predicate1条件相反
        Predicate<User> notpredicate1 = Predicates.not(predicate1);

        //List<User> filteredUsers = Lists.newArrayList(Iterators.filter(users.iterator(), predicate1));
        List<User> filteredUsers1 = Lists.newArrayList(Iterables.filter(users,predicate1));
        List<User> filteredUsers2 = Lists.newArrayList(Iterables.filter(users,predicate2));
        List<User> filteredUsers1and2 = Lists.newArrayList(Iterables.filter(users,predicate1_and_predicate2));
        List<User> filteredUsers1or2 = Lists.newArrayList(Iterables.filter(users,predicate1_or_predicate2));

        List<User> filteredUsersNot1 = Lists.newArrayList(Iterables.filter(users,notpredicate1));

        System.out.println("result size for filteredUsers1: " + filteredUsers1.size());          //2->  chang sun
        System.out.println("result size for filteredUsers2:  " + filteredUsers2.size());         //1-> chang
        System.out.println("result size for filteredUsers1and2:  " + filteredUsers1and2.size()); //1-> chang
        System.out.println("result size for filteredUsers1or2:  " + filteredUsers1or2.size());   //2-> chang sun

        System.out.println("result size for filteredUsersNot1:  " + filteredUsersNot1.size());   //1-> chen


    }

}