Function, Predicate

Function, Predicate的使用

Function用于把一种类型的对象转化为另一种类型的对象.
Predicate用于判断某个对象是否符合一定条件.

一.Function和Functions

　　在java开发中, 我们经常需要对一些对象进行处理, 然后返回我们想要的结果, 比如说:对日期进行格式化, 获取字符串等等.在guava中, 我们可以通过实现Function接口来实现类似的需求, 如下:

import com.google.common.base.Function;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Created by xinfengyao on 16-2-22.
 */
public class FunctionTest {
    public static void main(String[] args) {
        Function<Date, String> function = new Function<Date, String>() {
            @Override
            public String apply(Date date) {
                return new SimpleDateFormat("yyyy-MM-dd").format(date);
            }
        };

        System.out.println(function.apply(new Date()));

    }
}

打印结果为:

2016-02-22

　　我们看到, 调用Function接口中的apply()方法, 将我们想要处理的对象作为输入参数, 返回结果就是处理后我们想要的. Function接口中, 其实有两个方法, 我们一般只关心apply()方法.

package com.google.common.base;

import com.google.common.annotations.GwtCompatible;
import javax.annotation.Nullable;

@GwtCompatible
public interface Function<F, T> {
    @Nullable
    T apply(@Nullable F var1);

    boolean equals(@Nullable Object var1);
}

　　多数情况下, 我们需要自己实现Function接口, 以满足不同的需求. 不过Guava提供了工具类Functions, 其中包含了一些常用的Function实现. Functions中最重要的两个方法是forMap()和compose(). 通过实例代码, 学习这两个方法:

import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.collect.Maps;

import java.util.Map;

/**
 * Created by xinfengyao on 16-2-22.
 */
public class FunctionsTest {
    public static void main(String[] args) {
        Map<String, Integer> map = Maps.newHashMap();
        map.put("aaa", 1);
        map.put("bbb", 2);

        Function<String, Integer> function = Functions.forMap(map);
        /**
         * 调用apply()方法, 可以通过key获取对应的value
         * 当传给apply()中的key在map中不存在时, 就会抛出异常IllegalArgumentException
         */
        System.out.println(function.apply("aaa"));

        /**
         * 我们可以通过forMap()另一个重载方法避免抛出异常, 当key不存在时, 设置一个默认值
         */
        function = Functions.forMap(map, 0);
        System.out.println(function.apply("ccc"));

        /**
         * 有时候我们需要通过多个Function进行组合, 这时我们就需要用到compose()方法
         */
        Function<Integer, Integer> function2 = new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer input) {
                return input * input;
            }
        };

        /**
         * 将上面map中的值进行平方运算, 注意compose()方法中的输入参数的顺序不能颠倒:
         * Function<A, C> compose(Function<B, C> g, Function<A, ? extends B> f)
         */
        Function<String, Integer> result = Functions.compose(function2, function);
        System.out.println(result.apply("bbb"));
    }
}

运行结果:

1
0
4

　　通过运行结果, 我们能够看到compose()方法的内部执行过程:  假定Fuctions.compose()方法返回的Function为function1, compose()的第一个参数为function2, 第二个参数为function3, 那么调用function1.apply()方法时, 输入参数会传给function3的apply()方法, function3.apply()方法的返回结果作为function2.apply()方法的入参, function2.apply()方法的返回结果就是function1.apply()方法的执行结果.

二.Predicate和Predicates

　　如果说Function主要用于对象的转换, 那么Predicate则主要用作对象的过滤和筛选. Predicate和Function一样, 也有两个方法, 我们主要关心apply()方法.

package com.google.common.base;

import com.google.common.annotations.GwtCompatible;
import javax.annotation.Nullable;

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

    boolean equals(@Nullable Object var1);
}

通过下面这个例子学习Predicate的使用:

/**
 * Created by xinfengyao on 16-2-22.
 */
public class Person {
    private String name;
    private int age;
    private int height;
    // 省略getter和setter方法,  构造方法
}

import com.google.common.base.Predicate;

/**
 * Created by xinfengyao on 16-2-22.
 */
public class PredicateTest {
    public static void main(String[] args) {
        Predicate<Person> predicate = new Predicate<Person>() {
            @Override
            public boolean apply(Person person) {
               return person.getAge() > 18;
            }
        };

        Person person = new Person("tom", 23, 175);
        System.out.println(predicate.apply(person));
    }
}

打印结果:

true

与Function类似, Predicate也有对应的工具类Predicates. 下面来学习几个比较重要的方法: Predicates.not(), Predicates.or(), Predicates.and(), Predicates.compose()

 import com.google.common.base.Function;
 import com.google.common.base.Functions;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Maps;

 import java.util.Map;

 /**
  * Created by xinfengyao on 16-2-22.
  */
 public class PredicatesTest {
     public static void main(String[] args) {
         Predicate<Person> predicate1 = new Predicate<Person>() {
             @Override
             public boolean apply(Person person) {
                 return person.getAge() > 18;
             }
         };
         Predicate<Person> predicate2 = new Predicate<Person>() {
             @Override
             public boolean apply(Person person) {
                 return person.getHeight() > 175;
             }
         };

         Person person = new Person("Jack", 25, 170);
         Predicate<Person> predicate3 = Predicates.and(predicate1, predicate2);
         System.out.println(predicate3.apply(person));

         Predicate<Person> predicate4 = Predicates.not(predicate1);
         System.out.println(predicate4.apply(person));

         Predicate<Person> predicate5 = Predicates.or(predicate1, predicate2);
         System.out.println(predicate5.apply(person));

         Map<String, Person> personMap = Maps.newHashMap();
         personMap.put("marry", new Person("marry", 21, 165));
         personMap.put("bob", new Person("bob", 25, 180));
         Predicate<String> predicate6 = Predicates.compose(predicate2, Functions.forMap(personMap));
         System.out.println(predicate6.apply("marry"));

     }

 }

运行结果:

false
false
true
false

Predicates.compose()方法运行过程:  假定Predicates.compose()返回predicate1, compose()的第一个参数为predicate2, 第二个参数为function1; 则当调用predicate1.apply()方法时, 输入参数传递给function1, function1的返回结果作为predicate2的输入参数, predicate2的返回结果就是predicate1.apply()的执行结果.