commons之函数式编程Predicate和Transformer

Predicate

JDK、guava、Apache都提供Predicate断言类，用法大同小异。函数式编程 Predicate 它以一个Object对象为参数，处理后返回一个boolean值，检验某个对象是否满足某个条件。可以将其理解为IF的一种封装，也就是满足条件就执行，该接口有一个唯一的方法evaluate。
一般它的应用如下：

1. 相等判断：EqualPredicate

2. 非空判断：NotNullPredicate

3. 唯一判断：EqualPredicate

4. 自定义判断：重写Predicate接口中的evaluate()方法

5. 组合式判断：
   PredicateUtils.allPredicate(…) 添加多个Predicate元素， 都为真才为真
   PredicateUtils.andPredicate(…) 添加两个Predicate元素， 两个全为真才为真
   PredicateUtils.anyPredicate(…) 添加多个Predicate元素，任何一为真就为真

/**
 * 函数式编程 Predicate 它以一个Object对象为参数，处理后返回一个boolean值，检验某个对象是否满足某个条件。
 * 可以将其理解为IF的一种封装，也就是满足条件就执行，该接口有一个唯一的方法evaluate
 * @author Administrator
 *
 */
public class Demo01 {

    public static void main(String[] args) {
        equal();
//      notnull();
        unique();
        defined();
    }

    public static void defined(){
        System.out.println("====自定义判断====");
        Predicate<String> pre = new Predicate<String>(){
            @Override
            public boolean evaluate(String object) {
                return object.length()>5&&object.length()<10;
            }
        };

        Predicate<String> notnull=NotNullPredicate.notNullPredicate();
        Predicate<String> pre1 = PredicateUtils.allPredicate(pre,notnull);
        List<String> list =PredicatedList.predicatedList(new ArrayList<String>(), pre1);
        list.add("aaaaaa");
        list.add(null); //验证失败，出现异常
        list.add("aaa");


    }

    public static void unique(){
        System.out.println("====唯一性判断====");
        Predicate<String> pre = UniquePredicate.uniquePredicate();
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
//      list.add("aa");
        List<String> list1 = PredicatedList.predicatedList(list, pre);
    }

    public static void notnull(){
        System.out.println("====非空判断====");
        //Predicate notNull=NotNullPredicate.INSTANCE;
        Predicate<Object> pre=NotNullPredicate.notNullPredicate();
        String str =null;
        System.out.println(pre.evaluate(str)); //如果非空为true ,否则为false

        //添加容器值的判断
        List<Long> list =PredicatedList.predicatedList(new ArrayList<Long>(), pre);
        list.add(1000L);
        list.add(null); //验证失败，出现异常

    }

    public static void equal(){
        System.out.println("====相等判断====");
        //Predicate<String> pre = new EqualPredicate<String>("lfff");
        Predicate<String> pre = EqualPredicate.equalPredicate("lfff");
        System.out.println(pre.evaluate("lf"));

    }
}

Transformer

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.SwitchTransformer;

/**
 * 测试函数式编程 Transformer 类型转换
 * @author Administrator
 *
 */
public class Demo02 {
    public static void main(String[] args) {
        testInnerTransformer();
        defined();
    }

    public static void test01(){
        Transformer<Integer, Integer> trans = new Transformer<Integer, Integer>() {
            @Override
            public Integer transform(Integer input) {
                return input*2;
            }
        };

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        //CollectionUtils.transform和CollectionUtils.collect相似，
        //唯一不同的是CollectionUtils.collect会返回Collection集合，而CollectionUtils.transform没有返回值，只是处理
        CollectionUtils.transform(list, trans);  
        System.out.println(list);
    }

    public static void testInnerTransformer(){
        System.out.println("内置类型转换 长整型时间日期，转成指定格式的字符串");
        Transformer<Long,String> trans = new Transformer<Long, String>() {
            @Override
            public String transform(Long input) {
                return new SimpleDateFormat("yyyy-MM--dd").format(input);
            }
        };

        List<Long> list = new ArrayList<Long>();
        list.add(999999999999999L);
        list.add(30000000000L);
        System.out.println(list);//[999999999999999, 30000000000]

        //类似：程序猿出钱---开发商(中介)---农民工出力    借助工具类
        Collection<String> result = CollectionUtils.collect(list, trans);
        System.out.println(result);//[33658年09月27日, 1970年12月14日]
    }

    public static void defined(){
        System.out.println("==========自定义============");
        Predicate<Employee> pre1 = new Predicate<Employee>() {
            @Override
            public boolean evaluate(Employee object) {
                return object.getSalary()<1000;
            }
        };

        Predicate<Employee> pre2 = new Predicate<Employee>() {
            @Override
            public boolean evaluate(Employee object) {
                return object.getSalary()>1000;
            }
        };
        Predicate[] pre = {pre1,pre2};

        Transformer<Employee,Level> trans1 = new Transformer<Employee, Level>() {
            @Override
            public Level transform(Employee input) {
                return new Level(input.getName(), "农民");
            }
        };

        Transformer<Employee,Level> trans2 = new Transformer<Employee, Level>() {
            @Override
            public Level transform(Employee input) {
                return new Level(input.getName(), "地主");
            }
        };
        Transformer[] trans = {trans1,trans2};

        //Predicate数组跟Transformer，二者进行关联,SwitchTransformer功能有点像switch
        Transformer<Employee,Level> switch1 = new SwitchTransformer<>(pre, trans, null);
        //容器
        List<Employee> list = new ArrayList<Employee>();
        list.add(new Employee("张三", 10000));
        list.add(new Employee("李四", 999));

        Collection<Level> list2 = CollectionUtils.collect(list, switch1);
        //遍历容器
        Iterator<Level> levelIterator = list2.iterator();
        while (levelIterator.hasNext()) {
            System.out.println(levelIterator.next());
        }

    }
}

输出结果：
        内置类型转换 长整型时间日期，转成指定格式的字符串
        [999999999999999, 30000000000]
        [33658-09--27, 1970-12--14]
        ==========自定义============
        (码农：张三，水平：地主)
        (码农：李四，水平：农民)